diff --git a/.firebase/hosting.ZGlzdA.cache b/.firebase/hosting.ZGlzdA.cache
new file mode 100644
index 00000000..042878dc
--- /dev/null
+++ b/.firebase/hosting.ZGlzdA.cache
@@ -0,0 +1,10 @@
+assets/index.2813bd98.js,1683314578839,fc1f0cbfd2583ce17fe2196ae6b7542dbb5daf2c1349aeaa652024673810df92
+assets/index.b9154af1.js,1683559027962,4c940a5a1981b0bac1c8423b00260a0d05387afcb8c71620e6845b6be2fccdd6
+index.html,1683559165486,fb596d8b8f5e6c2c0fb329d17f1c97f4086c55f263f289ef41906f84ec22363e
+assets/fondoHome.d287116f.png,1683559165487,780f76c9de152739b12540398d5de6828690483a2541e32f5cee03e222dcb175
+assets/fondo.9df9d0fb.png,1683559165486,41418d20b2bb8fdeef1515bacb4480f20a686ce98180e75be07425a4b265e9da
+assets/index.07071509.css,1683559165487,bb7f4a9277ea22db2aa2dd3d25ddd59ad2279619ba64a8dd5af7204b06216b92
+assets/fondoDesktop.64fb7a8f.png,1683559165487,f0ff63e0500adf20cb6732f5c3921775f298de9168bd80decc110c216eff3579
+assets/Logo.528a4c8f.png,1683559165486,890910ce800a1f4c17af782527b03bb0a13d87c67fb34465b94990910ddbb86e
+assets/fondoHomeDesktop.5b401cef.png,1683559165487,67e1852ef5e3876dfd3877efbc3ab4a103236c02eb31889e23661b6210420e49
+assets/index.399e54be.js,1683559165487,ca03c711442920058542c2ec786bd36e402193aeb1cf86450ef153a37d39189d
diff --git a/.firebaserc b/.firebaserc
new file mode 100644
index 00000000..b02779a0
--- /dev/null
+++ b/.firebaserc
@@ -0,0 +1,5 @@
+{
+ "projects": {
+ "default": "social-network-dev-005"
+ }
+}
diff --git a/.gitignore b/.gitignore
index 47735411..471a9bf1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,4 +3,4 @@
coverage/
node_modules/
.yarn.lock
-package-lock.json
\ No newline at end of file
+package-lock.json
diff --git a/README.md b/README.md
index c64bad1e..f49f821c 100644
--- a/README.md
+++ b/README.md
@@ -1,554 +1,62 @@
-# Creando una Red Social
+# Emprende - Social-network
-## Índice
-
-* [1. Preámbulo](#1-preámbulo)
-* [2. Resumen del proyecto](#2-resumen-del-proyecto)
-* [3. Objetivos de aprendizaje](#3-objetivos-de-aprendizaje)
-* [4. Consideraciones generales](#4-consideraciones-generales)
-* [5. Criterios de aceptación mínimos del proyecto](#5-criterios-de-aceptación-mínimos-del-proyecto)
-* [6. Hacker edition](#6-hacker-edition)
-* [7. Entrega](#7-entrega)
-* [8. Pistas, tips y lecturas complementarias](#8-pistas-tips-y-lecturas-complementarias)
-
-## 1. Preámbulo
-
-Instagram, Snapchat, Twitter, Facebook, Twitch, Linkedin, etc. Las redes
-sociales han invadido nuestras vidas. Las amamos u odiamos, y muchos no podemos
-vivir sin ellas.
-
-
-
-Hay redes sociales de todo tipo y para todo tipo de intereses. Por ejemplo,
-en una ronda de financiamiento con inversionistas, se presentó una red social
-para químicos en la que los usuarios podían publicar artículos sobre sus
-investigaciones, comentar en los artículos de sus colegas, y filtrar artículos
-de acuerdo a determinadas etiquetas o su popularidad, lo más reciente, o lo
-más comentado.
-
-## 2. Resumen del proyecto
-
-En este proyecto construirás una Red Social sobre lo que decidan tú y tu equipo.
-Podría ser, por ejemplo, sobre alimentación saludable, feminismo, educación,
-salud, energías renovables, amantes de las [Empanadas](https://es.wikipedia.org/wiki/Empanada)
-o de los [Tacos de Canasta](https://es.wikipedia.org/wiki/Taco),
-de la [Feijoada](https://es.wikipedia.org/wiki/Feijoada), o de lo que sea.
-
-Tu Red Social tendrá que permitir a cualquier usuario crear una cuenta de acceso
-y loguearse con ella; crear, editar, borrar y _"likear"_ publicacciones.
-
-Por lo tanto, en este proyecto construirás una
-[Single-page Application (SPA)](https://es.wikipedia.org/wiki/Single-page_application)
-[_responsive_](https://curriculum.laboratoria.la/es/topics/css/02-responsive) (con más de una vista / página)
-en la que podamos **leer y escribir datos**.
-
-### Los objetivos generales de este proyecto son los siguientes
-
-* Desarrollar una SPA con temática de red social
-* Aplicar los conceptos de responsividad en el desarrollo de las vistas (templates)
-* Implementar un router para la navegación entre las diferentes vistas de la aplicación
-* Emplear un servicio externo para la persistencia de datos de la aplicación
-* Crear una suite de pruebas unitarias que permitan testear código asíncrono
-
-Para lograr estos objetivos, deberás aprender y hacer uso de las siguientes
-herramientas o habilidades técnicas:
-
-## 3. Objetivos de aprendizaje
-
-Reflexiona y luego marca los objetivos que has llegado a entender y aplicar en tu proyecto. Piensa en eso al decidir tu estrategia de trabajo.
-
-### HTML
-
-- [ ] **Uso de HTML semántico**
-
- Links
-
- * [HTML semántico](https://curriculum.laboratoria.la/es/topics/html/02-html5/02-semantic-html)
- * [Semantics - MDN Web Docs Glossary](https://developer.mozilla.org/en-US/docs/Glossary/Semantics#Semantics_in_HTML)
-
Links
-
- * [Intro a CSS](https://curriculum.laboratoria.la/es/topics/css/01-css/01-intro-css)
- * [CSS Selectors - MDN](https://developer.mozilla.org/es/docs/Web/CSS/CSS_Selectors)
-
Links
-
- * [Box Model & Display](https://curriculum.laboratoria.la/es/topics/css/01-css/02-boxmodel-and-display)
- * [The box model - MDN](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/The_box_model)
- * [Introduction to the CSS box model - MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Box_Model/Introduction_to_the_CSS_box_model)
- * [CSS display - MDN](https://developer.mozilla.org/pt-BR/docs/Web/CSS/display)
- * [display - CSS Tricks](https://css-tricks.com/almanac/properties/d/display/)
-
Links
-
- * [A Complete Guide to Flexbox - CSS Tricks](https://css-tricks.com/snippets/css/a-guide-to-flexbox/)
- * [Flexbox Froggy](https://flexboxfroggy.com/#es)
- * [Flexbox - MDN](https://developer.mozilla.org/en-US/docs/Learn/CSS/CSS_layout/Flexbox)
-
Links
-
- * [A Complete Guide to Grid - CSS Tricks](https://css-tricks.com/snippets/css/complete-guide-grid/)
- * [Grids - MDN](https://developer.mozilla.org/en-US/docs/Learn/CSS/CSS_layout/Grids)
-
Links
-
- * [Manipulación del DOM](https://curriculum.laboratoria.la/es/topics/browser/02-dom/03-1-dom-methods-selection)
- * [Introducción al DOM - MDN](https://developer.mozilla.org/es/docs/Web/API/Document_Object_Model/Introduction)
- * [Localizando elementos DOM usando selectores - MDN](https://developer.mozilla.org/es/docs/Web/API/Document_object_model/Locating_DOM_elements_using_selectors)
-
Links
-
- * [Introducción a eventos - MDN](https://developer.mozilla.org/es/docs/Learn/JavaScript/Building_blocks/Events)
- * [EventTarget.addEventListener() - MDN](https://developer.mozilla.org/es/docs/Web/API/EventTarget/addEventListener)
- * [EventTarget.removeEventListener() - MDN](https://developer.mozilla.org/es/docs/Web/API/EventTarget/removeEventListener)
- * [El objeto Event](https://developer.mozilla.org/es/docs/Web/API/Event)
-
Links
-
- * [Introducción al DOM](https://developer.mozilla.org/es/docs/Web/API/Document_Object_Model/Introduction)
- * [Node.appendChild() - MDN](https://developer.mozilla.org/es/docs/Web/API/Node/appendChild)
- * [Document.createElement() - MDN](https://developer.mozilla.org/es/docs/Web/API/Document/createElement)
- * [Document.createTextNode()](https://developer.mozilla.org/es/docs/Web/API/Document/createTextNode)
- * [Element.innerHTML - MDN](https://developer.mozilla.org/es/docs/Web/API/Element/innerHTML)
- * [Node.textContent - MDN](https://developer.mozilla.org/es/docs/Web/API/Node/textContent)
-
Links
-
- * [Manipulando el historial del navegador - MDN](https://developer.mozilla.org/es/docs/DOM/Manipulando_el_historial_del_navegador)
-
Links
-
- * [Arreglos](https://curriculum.laboratoria.la/es/topics/javascript/04-arrays)
- * [Array - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/)
- * [Array.prototype.sort() - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
- * [Array.prototype.forEach() - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
- * [Array.prototype.map() - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
- * [Array.prototype.filter() - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)
- * [Array.prototype.reduce() - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)
-
Links
-
- * [Objetos en JavaScript](https://curriculum.laboratoria.la/es/topics/javascript/05-objects/01-objects)
-
Links
-
- * [Valores, tipos de datos y operadores](https://curriculum.laboratoria.la/es/topics/javascript/01-basics/01-values-variables-and-types)
- * [Variables](https://curriculum.laboratoria.la/es/topics/javascript/01-basics/02-variables)
-
Links
-
- * [Estructuras condicionales y repetitivas](https://curriculum.laboratoria.la/es/topics/javascript/02-flow-control/01-conditionals-and-loops)
- * [Tomando decisiones en tu código — condicionales - MDN](https://developer.mozilla.org/es/docs/Learn/JavaScript/Building_blocks/conditionals)
-
Links
-
- * [Bucles (Loops)](https://curriculum.laboratoria.la/es/topics/javascript/02-flow-control/02-loops)
- * [Bucles e iteración - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Loops_and_iteration)
-
Links
-
- * [Funciones (control de flujo)](https://curriculum.laboratoria.la/es/topics/javascript/02-flow-control/03-functions)
- * [Funciones clásicas](https://curriculum.laboratoria.la/es/topics/javascript/03-functions/01-classic)
- * [Arrow Functions](https://curriculum.laboratoria.la/es/topics/javascript/03-functions/02-arrow)
- * [Funciones — bloques de código reutilizables - MDN](https://developer.mozilla.org/es/docs/Learn/JavaScript/Building_blocks/Functions)
-
Links
-
- * [Empezando con Jest - Documentación oficial](https://jestjs.io/docs/es-ES/getting-started)
-
Links
-
- * [Tests de código asincrónico con Jest - Documentación oficial](https://jestjs.io/docs/es-ES/asynchronous)
-
Links
-
- * [Manual Mocks con Jest - Documentación oficial](https://jestjs.io/docs/es-ES/manual-mocks)
-
Links
-
- * [import - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/import)
- * [export - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/export)
-
Links
-
- * [Función Callback - MDN](https://developer.mozilla.org/es/docs/Glossary/Callback_function)
-
Links
-
- * [Promise - MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Promise)
- * [How to Write a JavaScript Promise - freecodecamp (en inglés)](https://www.freecodecamp.org/news/how-to-write-a-javascript-promise-4ed8d44292b8/)
-
Links
-
- * [Sitio oficial de GitHub Pages](https://pages.github.com/)
-
Links
-
- * [Intro a testeos usabilidad](https://coda.io/@bootcamp-laboratoria/contenido-ux/test-de-usabilidad-15)
- * [Pruebas con Usuarios 1 — ¿Qué, cuándo y para qué testeamos?](https://eugeniacasabona.medium.com/pruebas-con-usuarios-1-qu%C3%A9-cu%C3%A1ndo-y-para-qu%C3%A9-testeamos-7c3a89b4b5e7)
-
Links
-
- * [Primeros pasos con Firebase Authentication en sitios web - Documentación oficial](https://firebase.google.com/docs/auth/web/start?hl=es)
- * [Administra usuarios en Firebase (onAuthStateChanged)](https://firebase.google.com/docs/auth/web/manage-users?hl=es#get_the_currently_signed-in_user)
-
Links
-
- * [Firestore - Documentación oficial](https://firebase.google.com/docs/firestore?hl=es)
- * [Reglas de seguridad de Firestore - Documentación oficial](https://firebase.google.com/docs/rules?hl=es)
- * [Obtén actualizaciones en tiempo real con Cloud Firestore - Documentación oficial](https://firebase.google.com/docs/firestore/query-data/listen?hl=es)
-
Error 404: p\xE1gina no encontrada.
+ volver al Inicio
+ Salir `;
+ const salir = postForm.querySelector(".goOut");
+ salir.addEventListener("click", () => {
+ signOut(auth).then(() => {
+ navigateTo2("/");
+ }).catch(() => {
+ });
+ });
+ const buttonPost = postForm.querySelector(".post");
+ buttonPost.addEventListener("click", (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector(".areaPost");
+ const postText = textarea.value;
+ if (postText.trim() !== "") {
+ post(postText);
+ } else {
+ alert("Ingrese post");
+ }
+ textarea.value = "";
+ });
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement("div");
+ postContainer.classList.add("divPost");
+ const name2 = document.createElement("h6");
+ name2.classList.add("userName");
+ postContainer.appendChild(name2);
+ name2.innerHTML = `${info.userEmail}`;
+ const textarea = document.createElement("textarea");
+ textarea.classList.add("showPost");
+ textarea.value = info.text;
+ postContainer.setAttribute("data-id", doc.id);
+ textarea.setAttribute("readonly", true);
+ postContainer.appendChild(textarea);
+ const buttonsContainer = document.createElement("div");
+ buttonsContainer.classList.add("buttonsPost");
+ const editButton = document.createElement("button");
+ editButton.classList.add("edit");
+ editButton.textContent = "Editar";
+ editButton.addEventListener("click", () => {
+ if (editButton.textContent === "Editar") {
+ editButton.textContent = "Guardar";
+ textarea.removeAttribute("readonly");
+ } else if (editButton.textContent === "Guardar") {
+ const editedTextarea = postContainer.querySelector("textarea").value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = "Editar";
+ textarea.setAttribute("readonly", true);
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+ const deleteButton = document.createElement("button");
+ deleteButton.classList.add("delete-btn");
+ deleteButton.textContent = "Eliminar";
+ deleteButton.addEventListener("click", () => {
+ const confirmDelete = confirm("\xBFEst\xE1s seguro que deseas eliminar este post?");
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest(".divPost").remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ const likeButton = document.createElement("button");
+ likeButton.classList.add("like-btn");
+ likeButton.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+ return postForm;
+ };
+ cf(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector(".showPost");
+ textarea.removeAttribute("readonly");
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute("data-id", doc.id);
+ }
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector(".like-btn");
+ buttonLike.innerHTML = `Inicia Sesi\xF3n
+ Reg\xEDstrate
+ Reg\xEDstrate con Google
+ `;
+ const logIn = section.querySelector(".logIn");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const register = section.querySelector(".register");
+ register.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const google = section.querySelector(".google");
+ google.addEventListener("click", () => {
+ loginWithGoogle().then(() => {
+ navigateTo2("/emprende");
+ }).catch(() => {
+ });
+ });
+ return section;
+}
+function login(navigateTo2) {
+ const sectionLogin = document.createElement("section");
+ sectionLogin.classList.add("sectionLogin");
+ sectionLogin.innerHTML = `
+ \xBFNo tienes una cuenta? Reg\xEDstrate
+
+ `;
+ const checkIn = sectionLogin.querySelector(".bottomTextLogin");
+ checkIn.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const formLogin = sectionLogin.querySelector(".formInteraction");
+ formLogin.addEventListener("submit", (e) => {
+ e.preventDefault();
+ const email = sectionLogin.querySelector(".inputEmail").value;
+ const password = sectionLogin.querySelector(".inputPassword").value;
+ signIn(email, password).then(() => {
+ navigateTo2("/emprende");
+ }).catch((err) => {
+ sectionLogin.querySelector(".note1").innerHTML = `${err.message}`;
+ });
+ });
+ return sectionLogin;
+}
+function create(navigateTo2) {
+ const sectionCreate = document.createElement("div");
+ sectionCreate.classList.add("creat");
+ sectionCreate.innerHTML = `
+ \xBFYa tienes cuenta? Iniciar Sesi\xF3n
+
+ `;
+ const logIn = sectionCreate.querySelector(".bottomText");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const form = sectionCreate.querySelector(".formCreateAccount");
+ form.addEventListener("submit", (e) => {
+ e.preventDefault();
+ const email = sectionCreate.querySelector(".card1").value;
+ const password = sectionCreate.querySelector(".card2").value;
+ createUser(email, password).then(() => {
+ navigateTo2("/emprende");
+ }).catch((err) => {
+ sectionCreate.querySelector(".alerta").innerHTML = `${err.message}`;
+ });
+ });
+ return sectionCreate;
+}
+const root = document.getElementById("root");
+root.append(init());
+const routes = [
+ { path: "/", component: init },
+ { path: "/login", component: login },
+ { path: "/register", component: create },
+ { path: "/error", component: mistake },
+ { path: "/emprende", component: home }
+];
+function navigateTo(hash) {
+ const route = routes.find((routeFind) => routeFind.path === hash);
+ if (route && route.component) {
+ window.history.pushState({}, route.path, window.location.origin + route.path);
+ if (root.firstChild) {
+ root.removeChild(root.firstChild);
+ }
+ root.append(route.component(navigateTo));
+ } else {
+ navigateTo("/error");
+ }
+}
+onAuthStateChanged(auth, (user) => {
+ if (user) {
+ navigateTo("/emprende");
+ } else if (window.location.pathname === "/emprende" && user === null) {
+ navigateTo();
+ } else {
+ navigateTo(window.location.pathname);
+ }
+});
diff --git a/dist/assets/index.399e54be.js b/dist/assets/index.399e54be.js
new file mode 100644
index 00000000..839bf589
--- /dev/null
+++ b/dist/assets/index.399e54be.js
@@ -0,0 +1,17991 @@
+(function polyfill() {
+ const relList = document.createElement("link").relList;
+ if (relList && relList.supports && relList.supports("modulepreload")) {
+ return;
+ }
+ for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
+ processPreload(link);
+ }
+ new MutationObserver((mutations) => {
+ for (const mutation of mutations) {
+ if (mutation.type !== "childList") {
+ continue;
+ }
+ for (const node of mutation.addedNodes) {
+ if (node.tagName === "LINK" && node.rel === "modulepreload")
+ processPreload(node);
+ }
+ }
+ }).observe(document, { childList: true, subtree: true });
+ function getFetchOpts(script) {
+ const fetchOpts = {};
+ if (script.integrity)
+ fetchOpts.integrity = script.integrity;
+ if (script.referrerpolicy)
+ fetchOpts.referrerPolicy = script.referrerpolicy;
+ if (script.crossorigin === "use-credentials")
+ fetchOpts.credentials = "include";
+ else if (script.crossorigin === "anonymous")
+ fetchOpts.credentials = "omit";
+ else
+ fetchOpts.credentials = "same-origin";
+ return fetchOpts;
+ }
+ function processPreload(link) {
+ if (link.ep)
+ return;
+ link.ep = true;
+ const fetchOpts = getFetchOpts(link);
+ fetch(link.href, fetchOpts);
+ }
+})();
+const style = "";
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const stringToByteArray$1 = function(str) {
+ const out = [];
+ let p2 = 0;
+ for (let i = 0; i < str.length; i++) {
+ let c = str.charCodeAt(i);
+ if (c < 128) {
+ out[p2++] = c;
+ } else if (c < 2048) {
+ out[p2++] = c >> 6 | 192;
+ out[p2++] = c & 63 | 128;
+ } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+ c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+ out[p2++] = c >> 18 | 240;
+ out[p2++] = c >> 12 & 63 | 128;
+ out[p2++] = c >> 6 & 63 | 128;
+ out[p2++] = c & 63 | 128;
+ } else {
+ out[p2++] = c >> 12 | 224;
+ out[p2++] = c >> 6 & 63 | 128;
+ out[p2++] = c & 63 | 128;
+ }
+ }
+ return out;
+};
+const byteArrayToString = function(bytes) {
+ const out = [];
+ let pos = 0, c = 0;
+ while (pos < bytes.length) {
+ const c1 = bytes[pos++];
+ if (c1 < 128) {
+ out[c++] = String.fromCharCode(c1);
+ } else if (c1 > 191 && c1 < 224) {
+ const c2 = bytes[pos++];
+ out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
+ } else if (c1 > 239 && c1 < 365) {
+ const c2 = bytes[pos++];
+ const c3 = bytes[pos++];
+ const c4 = bytes[pos++];
+ const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
+ out[c++] = String.fromCharCode(55296 + (u >> 10));
+ out[c++] = String.fromCharCode(56320 + (u & 1023));
+ } else {
+ const c2 = bytes[pos++];
+ const c3 = bytes[pos++];
+ out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
+ }
+ }
+ return out.join("");
+};
+const base64 = {
+ byteToCharMap_: null,
+ charToByteMap_: null,
+ byteToCharMapWebSafe_: null,
+ charToByteMapWebSafe_: null,
+ ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+ get ENCODED_VALS() {
+ return this.ENCODED_VALS_BASE + "+/=";
+ },
+ get ENCODED_VALS_WEBSAFE() {
+ return this.ENCODED_VALS_BASE + "-_.";
+ },
+ HAS_NATIVE_SUPPORT: typeof atob === "function",
+ encodeByteArray(input, webSafe) {
+ if (!Array.isArray(input)) {
+ throw Error("encodeByteArray takes an array as a parameter");
+ }
+ this.init_();
+ const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
+ const output = [];
+ for (let i = 0; i < input.length; i += 3) {
+ const byte1 = input[i];
+ const haveByte2 = i + 1 < input.length;
+ const byte2 = haveByte2 ? input[i + 1] : 0;
+ const haveByte3 = i + 2 < input.length;
+ const byte3 = haveByte3 ? input[i + 2] : 0;
+ const outByte1 = byte1 >> 2;
+ const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
+ let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
+ let outByte4 = byte3 & 63;
+ if (!haveByte3) {
+ outByte4 = 64;
+ if (!haveByte2) {
+ outByte3 = 64;
+ }
+ }
+ output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+ }
+ return output.join("");
+ },
+ encodeString(input, webSafe) {
+ if (this.HAS_NATIVE_SUPPORT && !webSafe) {
+ return btoa(input);
+ }
+ return this.encodeByteArray(stringToByteArray$1(input), webSafe);
+ },
+ decodeString(input, webSafe) {
+ if (this.HAS_NATIVE_SUPPORT && !webSafe) {
+ return atob(input);
+ }
+ return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
+ },
+ decodeStringToByteArray(input, webSafe) {
+ this.init_();
+ const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
+ const output = [];
+ for (let i = 0; i < input.length; ) {
+ const byte1 = charToByteMap[input.charAt(i++)];
+ const haveByte2 = i < input.length;
+ const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
+ ++i;
+ const haveByte3 = i < input.length;
+ const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
+ ++i;
+ const haveByte4 = i < input.length;
+ const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
+ ++i;
+ if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
+ throw new DecodeBase64StringError();
+ }
+ const outByte1 = byte1 << 2 | byte2 >> 4;
+ output.push(outByte1);
+ if (byte3 !== 64) {
+ const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
+ output.push(outByte2);
+ if (byte4 !== 64) {
+ const outByte3 = byte3 << 6 & 192 | byte4;
+ output.push(outByte3);
+ }
+ }
+ }
+ return output;
+ },
+ init_() {
+ if (!this.byteToCharMap_) {
+ this.byteToCharMap_ = {};
+ this.charToByteMap_ = {};
+ this.byteToCharMapWebSafe_ = {};
+ this.charToByteMapWebSafe_ = {};
+ for (let i = 0; i < this.ENCODED_VALS.length; i++) {
+ this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
+ this.charToByteMap_[this.byteToCharMap_[i]] = i;
+ this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
+ this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
+ if (i >= this.ENCODED_VALS_BASE.length) {
+ this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
+ this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
+ }
+ }
+ }
+ }
+};
+class DecodeBase64StringError extends Error {
+ constructor() {
+ super(...arguments);
+ this.name = "DecodeBase64StringError";
+ }
+}
+const base64Encode = function(str) {
+ const utf8Bytes = stringToByteArray$1(str);
+ return base64.encodeByteArray(utf8Bytes, true);
+};
+const base64urlEncodeWithoutPadding = function(str) {
+ return base64Encode(str).replace(/\./g, "");
+};
+const base64Decode = function(str) {
+ try {
+ return base64.decodeString(str, true);
+ } catch (e) {
+ console.error("base64Decode failed: ", e);
+ }
+ return null;
+};
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getGlobal() {
+ if (typeof self !== "undefined") {
+ return self;
+ }
+ if (typeof window !== "undefined") {
+ return window;
+ }
+ if (typeof global !== "undefined") {
+ return global;
+ }
+ throw new Error("Unable to locate global object.");
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;
+const getDefaultsFromEnvVariable = () => {
+ if (typeof process === "undefined" || typeof process.env === "undefined") {
+ return;
+ }
+ const defaultsJsonString = {}.__FIREBASE_DEFAULTS__;
+ if (defaultsJsonString) {
+ return JSON.parse(defaultsJsonString);
+ }
+};
+const getDefaultsFromCookie = () => {
+ if (typeof document === "undefined") {
+ return;
+ }
+ let match;
+ try {
+ match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
+ } catch (e) {
+ return;
+ }
+ const decoded = match && base64Decode(match[1]);
+ return decoded && JSON.parse(decoded);
+};
+const getDefaults = () => {
+ try {
+ return getDefaultsFromGlobal() || getDefaultsFromEnvVariable() || getDefaultsFromCookie();
+ } catch (e) {
+ console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);
+ return;
+ }
+};
+const getDefaultEmulatorHost = (productName) => {
+ var _a2, _b;
+ return (_b = (_a2 = getDefaults()) === null || _a2 === void 0 ? void 0 : _a2.emulatorHosts) === null || _b === void 0 ? void 0 : _b[productName];
+};
+const getDefaultEmulatorHostnameAndPort = (productName) => {
+ const host = getDefaultEmulatorHost(productName);
+ if (!host) {
+ return void 0;
+ }
+ const separatorIndex = host.lastIndexOf(":");
+ if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {
+ throw new Error(`Invalid host ${host} with no separate hostname and port!`);
+ }
+ const port = parseInt(host.substring(separatorIndex + 1), 10);
+ if (host[0] === "[") {
+ return [host.substring(1, separatorIndex - 1), port];
+ } else {
+ return [host.substring(0, separatorIndex), port];
+ }
+};
+const getDefaultAppConfig = () => {
+ var _a2;
+ return (_a2 = getDefaults()) === null || _a2 === void 0 ? void 0 : _a2.config;
+};
+const getExperimentalSetting = (name2) => {
+ var _a2;
+ return (_a2 = getDefaults()) === null || _a2 === void 0 ? void 0 : _a2[`_${name2}`];
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Deferred {
+ constructor() {
+ this.reject = () => {
+ };
+ this.resolve = () => {
+ };
+ this.promise = new Promise((resolve, reject) => {
+ this.resolve = resolve;
+ this.reject = reject;
+ });
+ }
+ wrapCallback(callback) {
+ return (error, value) => {
+ if (error) {
+ this.reject(error);
+ } else {
+ this.resolve(value);
+ }
+ if (typeof callback === "function") {
+ this.promise.catch(() => {
+ });
+ if (callback.length === 1) {
+ callback(error);
+ } else {
+ callback(error, value);
+ }
+ }
+ };
+ }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function createMockUserToken(token, projectId) {
+ if (token.uid) {
+ throw new Error('The "uid" field is no longer supported by mockUserToken. Please use "sub" instead for Firebase Auth User ID.');
+ }
+ const header = {
+ alg: "none",
+ type: "JWT"
+ };
+ const project = projectId || "demo-project";
+ const iat = token.iat || 0;
+ const sub = token.sub || token.user_id;
+ if (!sub) {
+ throw new Error("mockUserToken must contain 'sub' or 'user_id' field!");
+ }
+ const payload = Object.assign({
+ iss: `https://securetoken.google.com/${project}`,
+ aud: project,
+ iat,
+ exp: iat + 3600,
+ auth_time: iat,
+ sub,
+ user_id: sub,
+ firebase: {
+ sign_in_provider: "custom",
+ identities: {}
+ }
+ }, token);
+ const signature = "";
+ return [
+ base64urlEncodeWithoutPadding(JSON.stringify(header)),
+ base64urlEncodeWithoutPadding(JSON.stringify(payload)),
+ signature
+ ].join(".");
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getUA() {
+ if (typeof navigator !== "undefined" && typeof navigator["userAgent"] === "string") {
+ return navigator["userAgent"];
+ } else {
+ return "";
+ }
+}
+function isMobileCordova() {
+ return typeof window !== "undefined" && !!(window["cordova"] || window["phonegap"] || window["PhoneGap"]) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA());
+}
+function isBrowserExtension() {
+ const runtime = typeof chrome === "object" ? chrome.runtime : typeof browser === "object" ? browser.runtime : void 0;
+ return typeof runtime === "object" && runtime.id !== void 0;
+}
+function isReactNative() {
+ return typeof navigator === "object" && navigator["product"] === "ReactNative";
+}
+function isIE() {
+ const ua2 = getUA();
+ return ua2.indexOf("MSIE ") >= 0 || ua2.indexOf("Trident/") >= 0;
+}
+function isIndexedDBAvailable() {
+ try {
+ return typeof indexedDB === "object";
+ } catch (e) {
+ return false;
+ }
+}
+function validateIndexedDBOpenable() {
+ return new Promise((resolve, reject) => {
+ try {
+ let preExist = true;
+ const DB_CHECK_NAME = "validate-browser-context-for-indexeddb-analytics-module";
+ const request = self.indexedDB.open(DB_CHECK_NAME);
+ request.onsuccess = () => {
+ request.result.close();
+ if (!preExist) {
+ self.indexedDB.deleteDatabase(DB_CHECK_NAME);
+ }
+ resolve(true);
+ };
+ request.onupgradeneeded = () => {
+ preExist = false;
+ };
+ request.onerror = () => {
+ var _a2;
+ reject(((_a2 = request.error) === null || _a2 === void 0 ? void 0 : _a2.message) || "");
+ };
+ } catch (error) {
+ reject(error);
+ }
+ });
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ERROR_NAME = "FirebaseError";
+class FirebaseError extends Error {
+ constructor(code, message, customData) {
+ super(message);
+ this.code = code;
+ this.customData = customData;
+ this.name = ERROR_NAME;
+ Object.setPrototypeOf(this, FirebaseError.prototype);
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, ErrorFactory.prototype.create);
+ }
+ }
+}
+class ErrorFactory {
+ constructor(service, serviceName, errors) {
+ this.service = service;
+ this.serviceName = serviceName;
+ this.errors = errors;
+ }
+ create(code, ...data) {
+ const customData = data[0] || {};
+ const fullCode = `${this.service}/${code}`;
+ const template = this.errors[code];
+ const message = template ? replaceTemplate(template, customData) : "Error";
+ const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;
+ const error = new FirebaseError(fullCode, fullMessage, customData);
+ return error;
+ }
+}
+function replaceTemplate(template, data) {
+ return template.replace(PATTERN, (_, key) => {
+ const value = data[key];
+ return value != null ? String(value) : `<${key}?>`;
+ });
+}
+const PATTERN = /\{\$([^}]+)}/g;
+function isEmpty(obj) {
+ for (const key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ return false;
+ }
+ }
+ return true;
+}
+function deepEqual(a, b2) {
+ if (a === b2) {
+ return true;
+ }
+ const aKeys = Object.keys(a);
+ const bKeys = Object.keys(b2);
+ for (const k2 of aKeys) {
+ if (!bKeys.includes(k2)) {
+ return false;
+ }
+ const aProp = a[k2];
+ const bProp = b2[k2];
+ if (isObject(aProp) && isObject(bProp)) {
+ if (!deepEqual(aProp, bProp)) {
+ return false;
+ }
+ } else if (aProp !== bProp) {
+ return false;
+ }
+ }
+ for (const k2 of bKeys) {
+ if (!aKeys.includes(k2)) {
+ return false;
+ }
+ }
+ return true;
+}
+function isObject(thing) {
+ return thing !== null && typeof thing === "object";
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function querystring(querystringParams) {
+ const params = [];
+ for (const [key, value] of Object.entries(querystringParams)) {
+ if (Array.isArray(value)) {
+ value.forEach((arrayVal) => {
+ params.push(encodeURIComponent(key) + "=" + encodeURIComponent(arrayVal));
+ });
+ } else {
+ params.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
+ }
+ }
+ return params.length ? "&" + params.join("&") : "";
+}
+function querystringDecode(querystring2) {
+ const obj = {};
+ const tokens = querystring2.replace(/^\?/, "").split("&");
+ tokens.forEach((token) => {
+ if (token) {
+ const [key, value] = token.split("=");
+ obj[decodeURIComponent(key)] = decodeURIComponent(value);
+ }
+ });
+ return obj;
+}
+function extractQuerystring(url) {
+ const queryStart = url.indexOf("?");
+ if (!queryStart) {
+ return "";
+ }
+ const fragmentStart = url.indexOf("#", queryStart);
+ return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : void 0);
+}
+function createSubscribe(executor, onNoObservers) {
+ const proxy = new ObserverProxy(executor, onNoObservers);
+ return proxy.subscribe.bind(proxy);
+}
+class ObserverProxy {
+ constructor(executor, onNoObservers) {
+ this.observers = [];
+ this.unsubscribes = [];
+ this.observerCount = 0;
+ this.task = Promise.resolve();
+ this.finalized = false;
+ this.onNoObservers = onNoObservers;
+ this.task.then(() => {
+ executor(this);
+ }).catch((e) => {
+ this.error(e);
+ });
+ }
+ next(value) {
+ this.forEachObserver((observer) => {
+ observer.next(value);
+ });
+ }
+ error(error) {
+ this.forEachObserver((observer) => {
+ observer.error(error);
+ });
+ this.close(error);
+ }
+ complete() {
+ this.forEachObserver((observer) => {
+ observer.complete();
+ });
+ this.close();
+ }
+ subscribe(nextOrObserver, error, complete) {
+ let observer;
+ if (nextOrObserver === void 0 && error === void 0 && complete === void 0) {
+ throw new Error("Missing Observer.");
+ }
+ if (implementsAnyMethods(nextOrObserver, [
+ "next",
+ "error",
+ "complete"
+ ])) {
+ observer = nextOrObserver;
+ } else {
+ observer = {
+ next: nextOrObserver,
+ error,
+ complete
+ };
+ }
+ if (observer.next === void 0) {
+ observer.next = noop;
+ }
+ if (observer.error === void 0) {
+ observer.error = noop;
+ }
+ if (observer.complete === void 0) {
+ observer.complete = noop;
+ }
+ const unsub = this.unsubscribeOne.bind(this, this.observers.length);
+ if (this.finalized) {
+ this.task.then(() => {
+ try {
+ if (this.finalError) {
+ observer.error(this.finalError);
+ } else {
+ observer.complete();
+ }
+ } catch (e) {
+ }
+ return;
+ });
+ }
+ this.observers.push(observer);
+ return unsub;
+ }
+ unsubscribeOne(i) {
+ if (this.observers === void 0 || this.observers[i] === void 0) {
+ return;
+ }
+ delete this.observers[i];
+ this.observerCount -= 1;
+ if (this.observerCount === 0 && this.onNoObservers !== void 0) {
+ this.onNoObservers(this);
+ }
+ }
+ forEachObserver(fn2) {
+ if (this.finalized) {
+ return;
+ }
+ for (let i = 0; i < this.observers.length; i++) {
+ this.sendOne(i, fn2);
+ }
+ }
+ sendOne(i, fn2) {
+ this.task.then(() => {
+ if (this.observers !== void 0 && this.observers[i] !== void 0) {
+ try {
+ fn2(this.observers[i]);
+ } catch (e) {
+ if (typeof console !== "undefined" && console.error) {
+ console.error(e);
+ }
+ }
+ }
+ });
+ }
+ close(err) {
+ if (this.finalized) {
+ return;
+ }
+ this.finalized = true;
+ if (err !== void 0) {
+ this.finalError = err;
+ }
+ this.task.then(() => {
+ this.observers = void 0;
+ this.onNoObservers = void 0;
+ });
+ }
+}
+function implementsAnyMethods(obj, methods) {
+ if (typeof obj !== "object" || obj === null) {
+ return false;
+ }
+ for (const method of methods) {
+ if (method in obj && typeof obj[method] === "function") {
+ return true;
+ }
+ }
+ return false;
+}
+function noop() {
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getModularInstance(service) {
+ if (service && service._delegate) {
+ return service._delegate;
+ } else {
+ return service;
+ }
+}
+class Component {
+ constructor(name2, instanceFactory, type) {
+ this.name = name2;
+ this.instanceFactory = instanceFactory;
+ this.type = type;
+ this.multipleInstances = false;
+ this.serviceProps = {};
+ this.instantiationMode = "LAZY";
+ this.onInstanceCreated = null;
+ }
+ setInstantiationMode(mode) {
+ this.instantiationMode = mode;
+ return this;
+ }
+ setMultipleInstances(multipleInstances) {
+ this.multipleInstances = multipleInstances;
+ return this;
+ }
+ setServiceProps(props) {
+ this.serviceProps = props;
+ return this;
+ }
+ setInstanceCreatedCallback(callback) {
+ this.onInstanceCreated = callback;
+ return this;
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_ENTRY_NAME$1 = "[DEFAULT]";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Provider {
+ constructor(name2, container) {
+ this.name = name2;
+ this.container = container;
+ this.component = null;
+ this.instances = /* @__PURE__ */ new Map();
+ this.instancesDeferred = /* @__PURE__ */ new Map();
+ this.instancesOptions = /* @__PURE__ */ new Map();
+ this.onInitCallbacks = /* @__PURE__ */ new Map();
+ }
+ get(identifier) {
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
+ if (!this.instancesDeferred.has(normalizedIdentifier)) {
+ const deferred = new Deferred();
+ this.instancesDeferred.set(normalizedIdentifier, deferred);
+ if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
+ try {
+ const instance = this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier
+ });
+ if (instance) {
+ deferred.resolve(instance);
+ }
+ } catch (e) {
+ }
+ }
+ }
+ return this.instancesDeferred.get(normalizedIdentifier).promise;
+ }
+ getImmediate(options) {
+ var _a2;
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier);
+ const optional = (_a2 = options === null || options === void 0 ? void 0 : options.optional) !== null && _a2 !== void 0 ? _a2 : false;
+ if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
+ try {
+ return this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier
+ });
+ } catch (e) {
+ if (optional) {
+ return null;
+ } else {
+ throw e;
+ }
+ }
+ } else {
+ if (optional) {
+ return null;
+ } else {
+ throw Error(`Service ${this.name} is not available`);
+ }
+ }
+ }
+ getComponent() {
+ return this.component;
+ }
+ setComponent(component) {
+ if (component.name !== this.name) {
+ throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
+ }
+ if (this.component) {
+ throw Error(`Component for ${this.name} has already been provided`);
+ }
+ this.component = component;
+ if (!this.shouldAutoInitialize()) {
+ return;
+ }
+ if (isComponentEager(component)) {
+ try {
+ this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME$1 });
+ } catch (e) {
+ }
+ }
+ for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
+ try {
+ const instance = this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier
+ });
+ instanceDeferred.resolve(instance);
+ } catch (e) {
+ }
+ }
+ }
+ clearInstance(identifier = DEFAULT_ENTRY_NAME$1) {
+ this.instancesDeferred.delete(identifier);
+ this.instancesOptions.delete(identifier);
+ this.instances.delete(identifier);
+ }
+ async delete() {
+ const services = Array.from(this.instances.values());
+ await Promise.all([
+ ...services.filter((service) => "INTERNAL" in service).map((service) => service.INTERNAL.delete()),
+ ...services.filter((service) => "_delete" in service).map((service) => service._delete())
+ ]);
+ }
+ isComponentSet() {
+ return this.component != null;
+ }
+ isInitialized(identifier = DEFAULT_ENTRY_NAME$1) {
+ return this.instances.has(identifier);
+ }
+ getOptions(identifier = DEFAULT_ENTRY_NAME$1) {
+ return this.instancesOptions.get(identifier) || {};
+ }
+ initialize(opts = {}) {
+ const { options = {} } = opts;
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
+ if (this.isInitialized(normalizedIdentifier)) {
+ throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
+ }
+ if (!this.isComponentSet()) {
+ throw Error(`Component ${this.name} has not been registered yet`);
+ }
+ const instance = this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier,
+ options
+ });
+ for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
+ const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
+ if (normalizedIdentifier === normalizedDeferredIdentifier) {
+ instanceDeferred.resolve(instance);
+ }
+ }
+ return instance;
+ }
+ onInit(callback, identifier) {
+ var _a2;
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
+ const existingCallbacks = (_a2 = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a2 !== void 0 ? _a2 : /* @__PURE__ */ new Set();
+ existingCallbacks.add(callback);
+ this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
+ const existingInstance = this.instances.get(normalizedIdentifier);
+ if (existingInstance) {
+ callback(existingInstance, normalizedIdentifier);
+ }
+ return () => {
+ existingCallbacks.delete(callback);
+ };
+ }
+ invokeOnInitCallbacks(instance, identifier) {
+ const callbacks = this.onInitCallbacks.get(identifier);
+ if (!callbacks) {
+ return;
+ }
+ for (const callback of callbacks) {
+ try {
+ callback(instance, identifier);
+ } catch (_a2) {
+ }
+ }
+ }
+ getOrInitializeService({ instanceIdentifier, options = {} }) {
+ let instance = this.instances.get(instanceIdentifier);
+ if (!instance && this.component) {
+ instance = this.component.instanceFactory(this.container, {
+ instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),
+ options
+ });
+ this.instances.set(instanceIdentifier, instance);
+ this.instancesOptions.set(instanceIdentifier, options);
+ this.invokeOnInitCallbacks(instance, instanceIdentifier);
+ if (this.component.onInstanceCreated) {
+ try {
+ this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
+ } catch (_a2) {
+ }
+ }
+ }
+ return instance || null;
+ }
+ normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME$1) {
+ if (this.component) {
+ return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME$1;
+ } else {
+ return identifier;
+ }
+ }
+ shouldAutoInitialize() {
+ return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+ }
+}
+function normalizeIdentifierForFactory(identifier) {
+ return identifier === DEFAULT_ENTRY_NAME$1 ? void 0 : identifier;
+}
+function isComponentEager(component) {
+ return component.instantiationMode === "EAGER";
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ComponentContainer {
+ constructor(name2) {
+ this.name = name2;
+ this.providers = /* @__PURE__ */ new Map();
+ }
+ addComponent(component) {
+ const provider2 = this.getProvider(component.name);
+ if (provider2.isComponentSet()) {
+ throw new Error(`Component ${component.name} has already been registered with ${this.name}`);
+ }
+ provider2.setComponent(component);
+ }
+ addOrOverwriteComponent(component) {
+ const provider2 = this.getProvider(component.name);
+ if (provider2.isComponentSet()) {
+ this.providers.delete(component.name);
+ }
+ this.addComponent(component);
+ }
+ getProvider(name2) {
+ if (this.providers.has(name2)) {
+ return this.providers.get(name2);
+ }
+ const provider2 = new Provider(name2, this);
+ this.providers.set(name2, provider2);
+ return provider2;
+ }
+ getProviders() {
+ return Array.from(this.providers.values());
+ }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var LogLevel;
+(function(LogLevel2) {
+ LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+ LogLevel2[LogLevel2["VERBOSE"] = 1] = "VERBOSE";
+ LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+ LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+ LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+ LogLevel2[LogLevel2["SILENT"] = 5] = "SILENT";
+})(LogLevel || (LogLevel = {}));
+const levelStringToEnum = {
+ "debug": LogLevel.DEBUG,
+ "verbose": LogLevel.VERBOSE,
+ "info": LogLevel.INFO,
+ "warn": LogLevel.WARN,
+ "error": LogLevel.ERROR,
+ "silent": LogLevel.SILENT
+};
+const defaultLogLevel = LogLevel.INFO;
+const ConsoleMethod = {
+ [LogLevel.DEBUG]: "log",
+ [LogLevel.VERBOSE]: "log",
+ [LogLevel.INFO]: "info",
+ [LogLevel.WARN]: "warn",
+ [LogLevel.ERROR]: "error"
+};
+const defaultLogHandler = (instance, logType, ...args) => {
+ if (logType < instance.logLevel) {
+ return;
+ }
+ const now = new Date().toISOString();
+ const method = ConsoleMethod[logType];
+ if (method) {
+ console[method](`[${now}] ${instance.name}:`, ...args);
+ } else {
+ throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
+ }
+};
+class Logger {
+ constructor(name2) {
+ this.name = name2;
+ this._logLevel = defaultLogLevel;
+ this._logHandler = defaultLogHandler;
+ this._userLogHandler = null;
+ }
+ get logLevel() {
+ return this._logLevel;
+ }
+ set logLevel(val) {
+ if (!(val in LogLevel)) {
+ throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
+ }
+ this._logLevel = val;
+ }
+ setLogLevel(val) {
+ this._logLevel = typeof val === "string" ? levelStringToEnum[val] : val;
+ }
+ get logHandler() {
+ return this._logHandler;
+ }
+ set logHandler(val) {
+ if (typeof val !== "function") {
+ throw new TypeError("Value assigned to `logHandler` must be a function");
+ }
+ this._logHandler = val;
+ }
+ get userLogHandler() {
+ return this._userLogHandler;
+ }
+ set userLogHandler(val) {
+ this._userLogHandler = val;
+ }
+ debug(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
+ this._logHandler(this, LogLevel.DEBUG, ...args);
+ }
+ log(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);
+ this._logHandler(this, LogLevel.VERBOSE, ...args);
+ }
+ info(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
+ this._logHandler(this, LogLevel.INFO, ...args);
+ }
+ warn(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
+ this._logHandler(this, LogLevel.WARN, ...args);
+ }
+ error(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
+ this._logHandler(this, LogLevel.ERROR, ...args);
+ }
+}
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+ return idbProxyableTypes || (idbProxyableTypes = [
+ IDBDatabase,
+ IDBObjectStore,
+ IDBIndex,
+ IDBCursor,
+ IDBTransaction
+ ]);
+}
+function getCursorAdvanceMethods() {
+ return cursorAdvanceMethods || (cursorAdvanceMethods = [
+ IDBCursor.prototype.advance,
+ IDBCursor.prototype.continue,
+ IDBCursor.prototype.continuePrimaryKey
+ ]);
+}
+const cursorRequestMap = /* @__PURE__ */ new WeakMap();
+const transactionDoneMap = /* @__PURE__ */ new WeakMap();
+const transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
+const transformCache = /* @__PURE__ */ new WeakMap();
+const reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+ const promise = new Promise((resolve, reject) => {
+ const unlisten = () => {
+ request.removeEventListener("success", success);
+ request.removeEventListener("error", error);
+ };
+ const success = () => {
+ resolve(wrap(request.result));
+ unlisten();
+ };
+ const error = () => {
+ reject(request.error);
+ unlisten();
+ };
+ request.addEventListener("success", success);
+ request.addEventListener("error", error);
+ });
+ promise.then((value) => {
+ if (value instanceof IDBCursor) {
+ cursorRequestMap.set(value, request);
+ }
+ }).catch(() => {
+ });
+ reverseTransformCache.set(promise, request);
+ return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+ if (transactionDoneMap.has(tx))
+ return;
+ const done = new Promise((resolve, reject) => {
+ const unlisten = () => {
+ tx.removeEventListener("complete", complete);
+ tx.removeEventListener("error", error);
+ tx.removeEventListener("abort", error);
+ };
+ const complete = () => {
+ resolve();
+ unlisten();
+ };
+ const error = () => {
+ reject(tx.error || new DOMException("AbortError", "AbortError"));
+ unlisten();
+ };
+ tx.addEventListener("complete", complete);
+ tx.addEventListener("error", error);
+ tx.addEventListener("abort", error);
+ });
+ transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+ get(target, prop, receiver) {
+ if (target instanceof IDBTransaction) {
+ if (prop === "done")
+ return transactionDoneMap.get(target);
+ if (prop === "objectStoreNames") {
+ return target.objectStoreNames || transactionStoreNamesMap.get(target);
+ }
+ if (prop === "store") {
+ return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+ }
+ }
+ return wrap(target[prop]);
+ },
+ set(target, prop, value) {
+ target[prop] = value;
+ return true;
+ },
+ has(target, prop) {
+ if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+ return true;
+ }
+ return prop in target;
+ }
+};
+function replaceTraps(callback) {
+ idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+ if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
+ return function(storeNames, ...args) {
+ const tx = func.call(unwrap(this), storeNames, ...args);
+ transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+ return wrap(tx);
+ };
+ }
+ if (getCursorAdvanceMethods().includes(func)) {
+ return function(...args) {
+ func.apply(unwrap(this), args);
+ return wrap(cursorRequestMap.get(this));
+ };
+ }
+ return function(...args) {
+ return wrap(func.apply(unwrap(this), args));
+ };
+}
+function transformCachableValue(value) {
+ if (typeof value === "function")
+ return wrapFunction(value);
+ if (value instanceof IDBTransaction)
+ cacheDonePromiseForTransaction(value);
+ if (instanceOfAny(value, getIdbProxyableTypes()))
+ return new Proxy(value, idbProxyTraps);
+ return value;
+}
+function wrap(value) {
+ if (value instanceof IDBRequest)
+ return promisifyRequest(value);
+ if (transformCache.has(value))
+ return transformCache.get(value);
+ const newValue = transformCachableValue(value);
+ if (newValue !== value) {
+ transformCache.set(value, newValue);
+ reverseTransformCache.set(newValue, value);
+ }
+ return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name2, version2, { blocked, upgrade, blocking, terminated } = {}) {
+ const request = indexedDB.open(name2, version2);
+ const openPromise = wrap(request);
+ if (upgrade) {
+ request.addEventListener("upgradeneeded", (event) => {
+ upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction));
+ });
+ }
+ if (blocked)
+ request.addEventListener("blocked", () => blocked());
+ openPromise.then((db2) => {
+ if (terminated)
+ db2.addEventListener("close", () => terminated());
+ if (blocking)
+ db2.addEventListener("versionchange", () => blocking());
+ }).catch(() => {
+ });
+ return openPromise;
+}
+const readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+const writeMethods = ["put", "add", "delete", "clear"];
+const cachedMethods = /* @__PURE__ */ new Map();
+function getMethod(target, prop) {
+ if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+ return;
+ }
+ if (cachedMethods.get(prop))
+ return cachedMethods.get(prop);
+ const targetFuncName = prop.replace(/FromIndex$/, "");
+ const useIndex = prop !== targetFuncName;
+ const isWrite = writeMethods.includes(targetFuncName);
+ if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+ return;
+ }
+ const method = async function(storeName, ...args) {
+ const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+ let target2 = tx.store;
+ if (useIndex)
+ target2 = target2.index(args.shift());
+ return (await Promise.all([
+ target2[targetFuncName](...args),
+ isWrite && tx.done
+ ]))[0];
+ };
+ cachedMethods.set(prop, method);
+ return method;
+}
+replaceTraps((oldTraps) => ({
+ ...oldTraps,
+ get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+ has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class PlatformLoggerServiceImpl {
+ constructor(container) {
+ this.container = container;
+ }
+ getPlatformInfoString() {
+ const providers = this.container.getProviders();
+ return providers.map((provider2) => {
+ if (isVersionServiceProvider(provider2)) {
+ const service = provider2.getImmediate();
+ return `${service.library}/${service.version}`;
+ } else {
+ return null;
+ }
+ }).filter((logString) => logString).join(" ");
+ }
+}
+function isVersionServiceProvider(provider2) {
+ const component = provider2.getComponent();
+ return (component === null || component === void 0 ? void 0 : component.type) === "VERSION";
+}
+const name$o = "@firebase/app";
+const version$1$1 = "0.9.7";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger = new Logger("@firebase/app");
+const name$n = "@firebase/app-compat";
+const name$m = "@firebase/analytics-compat";
+const name$l = "@firebase/analytics";
+const name$k = "@firebase/app-check-compat";
+const name$j = "@firebase/app-check";
+const name$i = "@firebase/auth";
+const name$h = "@firebase/auth-compat";
+const name$g = "@firebase/database";
+const name$f = "@firebase/database-compat";
+const name$e = "@firebase/functions";
+const name$d = "@firebase/functions-compat";
+const name$c = "@firebase/installations";
+const name$b = "@firebase/installations-compat";
+const name$a = "@firebase/messaging";
+const name$9 = "@firebase/messaging-compat";
+const name$8 = "@firebase/performance";
+const name$7 = "@firebase/performance-compat";
+const name$6 = "@firebase/remote-config";
+const name$5 = "@firebase/remote-config-compat";
+const name$4 = "@firebase/storage";
+const name$3 = "@firebase/storage-compat";
+const name$2 = "@firebase/firestore";
+const name$1$1 = "@firebase/firestore-compat";
+const name$p = "firebase";
+const version$2 = "9.19.1";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_ENTRY_NAME = "[DEFAULT]";
+const PLATFORM_LOG_STRING = {
+ [name$o]: "fire-core",
+ [name$n]: "fire-core-compat",
+ [name$l]: "fire-analytics",
+ [name$m]: "fire-analytics-compat",
+ [name$j]: "fire-app-check",
+ [name$k]: "fire-app-check-compat",
+ [name$i]: "fire-auth",
+ [name$h]: "fire-auth-compat",
+ [name$g]: "fire-rtdb",
+ [name$f]: "fire-rtdb-compat",
+ [name$e]: "fire-fn",
+ [name$d]: "fire-fn-compat",
+ [name$c]: "fire-iid",
+ [name$b]: "fire-iid-compat",
+ [name$a]: "fire-fcm",
+ [name$9]: "fire-fcm-compat",
+ [name$8]: "fire-perf",
+ [name$7]: "fire-perf-compat",
+ [name$6]: "fire-rc",
+ [name$5]: "fire-rc-compat",
+ [name$4]: "fire-gcs",
+ [name$3]: "fire-gcs-compat",
+ [name$2]: "fire-fst",
+ [name$1$1]: "fire-fst-compat",
+ "fire-js": "fire-js",
+ [name$p]: "fire-js-all"
+};
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const _apps = /* @__PURE__ */ new Map();
+const _components = /* @__PURE__ */ new Map();
+function _addComponent(app2, component) {
+ try {
+ app2.container.addComponent(component);
+ } catch (e) {
+ logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app2.name}`, e);
+ }
+}
+function _registerComponent(component) {
+ const componentName = component.name;
+ if (_components.has(componentName)) {
+ logger.debug(`There were multiple attempts to register component ${componentName}.`);
+ return false;
+ }
+ _components.set(componentName, component);
+ for (const app2 of _apps.values()) {
+ _addComponent(app2, component);
+ }
+ return true;
+}
+function _getProvider(app2, name2) {
+ const heartbeatController = app2.container.getProvider("heartbeat").getImmediate({ optional: true });
+ if (heartbeatController) {
+ void heartbeatController.triggerHeartbeat();
+ }
+ return app2.container.getProvider(name2);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ERRORS = {
+ ["no-app"]: "No Firebase App '{$appName}' has been created - call Firebase App.initializeApp()",
+ ["bad-app-name"]: "Illegal App name: '{$appName}",
+ ["duplicate-app"]: "Firebase App named '{$appName}' already exists with different options or config",
+ ["app-deleted"]: "Firebase App named '{$appName}' already deleted",
+ ["no-options"]: "Need to provide options, when not being deployed to hosting via source.",
+ ["invalid-app-argument"]: "firebase.{$appName}() takes either no argument or a Firebase App instance.",
+ ["invalid-log-argument"]: "First argument to `onLog` must be null or a function.",
+ ["idb-open"]: "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
+ ["idb-get"]: "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
+ ["idb-set"]: "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
+ ["idb-delete"]: "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}."
+};
+const ERROR_FACTORY = new ErrorFactory("app", "Firebase", ERRORS);
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FirebaseAppImpl {
+ constructor(options, config, container) {
+ this._isDeleted = false;
+ this._options = Object.assign({}, options);
+ this._config = Object.assign({}, config);
+ this._name = config.name;
+ this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;
+ this._container = container;
+ this.container.addComponent(new Component("app", () => this, "PUBLIC"));
+ }
+ get automaticDataCollectionEnabled() {
+ this.checkDestroyed();
+ return this._automaticDataCollectionEnabled;
+ }
+ set automaticDataCollectionEnabled(val) {
+ this.checkDestroyed();
+ this._automaticDataCollectionEnabled = val;
+ }
+ get name() {
+ this.checkDestroyed();
+ return this._name;
+ }
+ get options() {
+ this.checkDestroyed();
+ return this._options;
+ }
+ get config() {
+ this.checkDestroyed();
+ return this._config;
+ }
+ get container() {
+ return this._container;
+ }
+ get isDeleted() {
+ return this._isDeleted;
+ }
+ set isDeleted(val) {
+ this._isDeleted = val;
+ }
+ checkDestroyed() {
+ if (this.isDeleted) {
+ throw ERROR_FACTORY.create("app-deleted", { appName: this._name });
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const SDK_VERSION = version$2;
+function initializeApp(_options, rawConfig = {}) {
+ let options = _options;
+ if (typeof rawConfig !== "object") {
+ const name3 = rawConfig;
+ rawConfig = { name: name3 };
+ }
+ const config = Object.assign({ name: DEFAULT_ENTRY_NAME, automaticDataCollectionEnabled: false }, rawConfig);
+ const name2 = config.name;
+ if (typeof name2 !== "string" || !name2) {
+ throw ERROR_FACTORY.create("bad-app-name", {
+ appName: String(name2)
+ });
+ }
+ options || (options = getDefaultAppConfig());
+ if (!options) {
+ throw ERROR_FACTORY.create("no-options");
+ }
+ const existingApp = _apps.get(name2);
+ if (existingApp) {
+ if (deepEqual(options, existingApp.options) && deepEqual(config, existingApp.config)) {
+ return existingApp;
+ } else {
+ throw ERROR_FACTORY.create("duplicate-app", { appName: name2 });
+ }
+ }
+ const container = new ComponentContainer(name2);
+ for (const component of _components.values()) {
+ container.addComponent(component);
+ }
+ const newApp = new FirebaseAppImpl(options, config, container);
+ _apps.set(name2, newApp);
+ return newApp;
+}
+function getApp(name2 = DEFAULT_ENTRY_NAME) {
+ const app2 = _apps.get(name2);
+ if (!app2 && name2 === DEFAULT_ENTRY_NAME) {
+ return initializeApp();
+ }
+ if (!app2) {
+ throw ERROR_FACTORY.create("no-app", { appName: name2 });
+ }
+ return app2;
+}
+function registerVersion(libraryKeyOrName, version2, variant) {
+ var _a2;
+ let library = (_a2 = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a2 !== void 0 ? _a2 : libraryKeyOrName;
+ if (variant) {
+ library += `-${variant}`;
+ }
+ const libraryMismatch = library.match(/\s|\//);
+ const versionMismatch = version2.match(/\s|\//);
+ if (libraryMismatch || versionMismatch) {
+ const warning = [
+ `Unable to register library "${library}" with version "${version2}":`
+ ];
+ if (libraryMismatch) {
+ warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
+ }
+ if (libraryMismatch && versionMismatch) {
+ warning.push("and");
+ }
+ if (versionMismatch) {
+ warning.push(`version name "${version2}" contains illegal characters (whitespace or "/")`);
+ }
+ logger.warn(warning.join(" "));
+ return;
+ }
+ _registerComponent(new Component(`${library}-version`, () => ({ library, version: version2 }), "VERSION"));
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DB_NAME$1 = "firebase-heartbeat-database";
+const DB_VERSION$1 = 1;
+const STORE_NAME = "firebase-heartbeat-store";
+let dbPromise = null;
+function getDbPromise() {
+ if (!dbPromise) {
+ dbPromise = openDB(DB_NAME$1, DB_VERSION$1, {
+ upgrade: (db2, oldVersion) => {
+ switch (oldVersion) {
+ case 0:
+ db2.createObjectStore(STORE_NAME);
+ }
+ }
+ }).catch((e) => {
+ throw ERROR_FACTORY.create("idb-open", {
+ originalErrorMessage: e.message
+ });
+ });
+ }
+ return dbPromise;
+}
+async function readHeartbeatsFromIndexedDB(app2) {
+ try {
+ const db2 = await getDbPromise();
+ return db2.transaction(STORE_NAME).objectStore(STORE_NAME).get(computeKey(app2));
+ } catch (e) {
+ if (e instanceof FirebaseError) {
+ logger.warn(e.message);
+ } else {
+ const idbGetError = ERROR_FACTORY.create("idb-get", {
+ originalErrorMessage: e === null || e === void 0 ? void 0 : e.message
+ });
+ logger.warn(idbGetError.message);
+ }
+ }
+}
+async function writeHeartbeatsToIndexedDB(app2, heartbeatObject) {
+ try {
+ const db2 = await getDbPromise();
+ const tx = db2.transaction(STORE_NAME, "readwrite");
+ const objectStore = tx.objectStore(STORE_NAME);
+ await objectStore.put(heartbeatObject, computeKey(app2));
+ return tx.done;
+ } catch (e) {
+ if (e instanceof FirebaseError) {
+ logger.warn(e.message);
+ } else {
+ const idbGetError = ERROR_FACTORY.create("idb-set", {
+ originalErrorMessage: e === null || e === void 0 ? void 0 : e.message
+ });
+ logger.warn(idbGetError.message);
+ }
+ }
+}
+function computeKey(app2) {
+ return `${app2.name}!${app2.options.appId}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const MAX_HEADER_BYTES = 1024;
+const STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1e3;
+class HeartbeatServiceImpl {
+ constructor(container) {
+ this.container = container;
+ this._heartbeatsCache = null;
+ const app2 = this.container.getProvider("app").getImmediate();
+ this._storage = new HeartbeatStorageImpl(app2);
+ this._heartbeatsCachePromise = this._storage.read().then((result) => {
+ this._heartbeatsCache = result;
+ return result;
+ });
+ }
+ async triggerHeartbeat() {
+ const platformLogger = this.container.getProvider("platform-logger").getImmediate();
+ const agent = platformLogger.getPlatformInfoString();
+ const date = getUTCDateString();
+ if (this._heartbeatsCache === null) {
+ this._heartbeatsCache = await this._heartbeatsCachePromise;
+ }
+ if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some((singleDateHeartbeat) => singleDateHeartbeat.date === date)) {
+ return;
+ } else {
+ this._heartbeatsCache.heartbeats.push({ date, agent });
+ }
+ this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter((singleDateHeartbeat) => {
+ const hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();
+ const now = Date.now();
+ return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;
+ });
+ return this._storage.overwrite(this._heartbeatsCache);
+ }
+ async getHeartbeatsHeader() {
+ if (this._heartbeatsCache === null) {
+ await this._heartbeatsCachePromise;
+ }
+ if (this._heartbeatsCache === null || this._heartbeatsCache.heartbeats.length === 0) {
+ return "";
+ }
+ const date = getUTCDateString();
+ const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
+ const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
+ this._heartbeatsCache.lastSentHeartbeatDate = date;
+ if (unsentEntries.length > 0) {
+ this._heartbeatsCache.heartbeats = unsentEntries;
+ await this._storage.overwrite(this._heartbeatsCache);
+ } else {
+ this._heartbeatsCache.heartbeats = [];
+ void this._storage.overwrite(this._heartbeatsCache);
+ }
+ return headerString;
+ }
+}
+function getUTCDateString() {
+ const today = new Date();
+ return today.toISOString().substring(0, 10);
+}
+function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
+ const heartbeatsToSend = [];
+ let unsentEntries = heartbeatsCache.slice();
+ for (const singleDateHeartbeat of heartbeatsCache) {
+ const heartbeatEntry = heartbeatsToSend.find((hb2) => hb2.agent === singleDateHeartbeat.agent);
+ if (!heartbeatEntry) {
+ heartbeatsToSend.push({
+ agent: singleDateHeartbeat.agent,
+ dates: [singleDateHeartbeat.date]
+ });
+ if (countBytes(heartbeatsToSend) > maxSize) {
+ heartbeatsToSend.pop();
+ break;
+ }
+ } else {
+ heartbeatEntry.dates.push(singleDateHeartbeat.date);
+ if (countBytes(heartbeatsToSend) > maxSize) {
+ heartbeatEntry.dates.pop();
+ break;
+ }
+ }
+ unsentEntries = unsentEntries.slice(1);
+ }
+ return {
+ heartbeatsToSend,
+ unsentEntries
+ };
+}
+class HeartbeatStorageImpl {
+ constructor(app2) {
+ this.app = app2;
+ this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+ }
+ async runIndexedDBEnvironmentCheck() {
+ if (!isIndexedDBAvailable()) {
+ return false;
+ } else {
+ return validateIndexedDBOpenable().then(() => true).catch(() => false);
+ }
+ }
+ async read() {
+ const canUseIndexedDB = await this._canUseIndexedDBPromise;
+ if (!canUseIndexedDB) {
+ return { heartbeats: [] };
+ } else {
+ const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
+ return idbHeartbeatObject || { heartbeats: [] };
+ }
+ }
+ async overwrite(heartbeatsObject) {
+ var _a2;
+ const canUseIndexedDB = await this._canUseIndexedDBPromise;
+ if (!canUseIndexedDB) {
+ return;
+ } else {
+ const existingHeartbeatsObject = await this.read();
+ return writeHeartbeatsToIndexedDB(this.app, {
+ lastSentHeartbeatDate: (_a2 = heartbeatsObject.lastSentHeartbeatDate) !== null && _a2 !== void 0 ? _a2 : existingHeartbeatsObject.lastSentHeartbeatDate,
+ heartbeats: heartbeatsObject.heartbeats
+ });
+ }
+ }
+ async add(heartbeatsObject) {
+ var _a2;
+ const canUseIndexedDB = await this._canUseIndexedDBPromise;
+ if (!canUseIndexedDB) {
+ return;
+ } else {
+ const existingHeartbeatsObject = await this.read();
+ return writeHeartbeatsToIndexedDB(this.app, {
+ lastSentHeartbeatDate: (_a2 = heartbeatsObject.lastSentHeartbeatDate) !== null && _a2 !== void 0 ? _a2 : existingHeartbeatsObject.lastSentHeartbeatDate,
+ heartbeats: [
+ ...existingHeartbeatsObject.heartbeats,
+ ...heartbeatsObject.heartbeats
+ ]
+ });
+ }
+ }
+}
+function countBytes(heartbeatsCache) {
+ return base64urlEncodeWithoutPadding(
+ JSON.stringify({ version: 2, heartbeats: heartbeatsCache })
+ ).length;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function registerCoreComponents(variant) {
+ _registerComponent(new Component("platform-logger", (container) => new PlatformLoggerServiceImpl(container), "PRIVATE"));
+ _registerComponent(new Component("heartbeat", (container) => new HeartbeatServiceImpl(container), "PRIVATE"));
+ registerVersion(name$o, version$1$1, variant);
+ registerVersion(name$o, version$1$1, "esm2017");
+ registerVersion("fire-js", "");
+}
+registerCoreComponents("");
+function __rest(s, e) {
+ var t2 = {};
+ for (var p2 in s)
+ if (Object.prototype.hasOwnProperty.call(s, p2) && e.indexOf(p2) < 0)
+ t2[p2] = s[p2];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p2 = Object.getOwnPropertySymbols(s); i < p2.length; i++) {
+ if (e.indexOf(p2[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p2[i]))
+ t2[p2[i]] = s[p2[i]];
+ }
+ return t2;
+}
+function _prodErrorMap() {
+ return {
+ ["dependent-sdk-initialized-before-auth"]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK."
+ };
+}
+const prodErrorMap = _prodErrorMap;
+const _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory("auth", "Firebase", _prodErrorMap());
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logClient = new Logger("@firebase/auth");
+function _logError(msg, ...args) {
+ if (logClient.logLevel <= LogLevel.ERROR) {
+ logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _fail(authOrCode, ...rest) {
+ throw createErrorInternal(authOrCode, ...rest);
+}
+function _createError(authOrCode, ...rest) {
+ return createErrorInternal(authOrCode, ...rest);
+}
+function _errorWithCustomMessage(auth2, code, message) {
+ const errorMap = Object.assign(Object.assign({}, prodErrorMap()), { [code]: message });
+ const factory = new ErrorFactory("auth", "Firebase", errorMap);
+ return factory.create(code, {
+ appName: auth2.name
+ });
+}
+function _assertInstanceOf(auth2, object, instance) {
+ const constructorInstance = instance;
+ if (!(object instanceof constructorInstance)) {
+ if (constructorInstance.name !== object.constructor.name) {
+ _fail(auth2, "argument-error");
+ }
+ throw _errorWithCustomMessage(auth2, "argument-error", `Type of ${object.constructor.name} does not match expected instance.Did you pass a reference from a different Auth SDK?`);
+ }
+}
+function createErrorInternal(authOrCode, ...rest) {
+ if (typeof authOrCode !== "string") {
+ const code = rest[0];
+ const fullParams = [...rest.slice(1)];
+ if (fullParams[0]) {
+ fullParams[0].appName = authOrCode.name;
+ }
+ return authOrCode._errorFactory.create(code, ...fullParams);
+ }
+ return _DEFAULT_AUTH_ERROR_FACTORY.create(authOrCode, ...rest);
+}
+function _assert(assertion, authOrCode, ...rest) {
+ if (!assertion) {
+ throw createErrorInternal(authOrCode, ...rest);
+ }
+}
+function debugFail(failure) {
+ const message = `INTERNAL ASSERTION FAILED: ` + failure;
+ _logError(message);
+ throw new Error(message);
+}
+function debugAssert(assertion, message) {
+ if (!assertion) {
+ debugFail(message);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const instanceCache = /* @__PURE__ */ new Map();
+function _getInstance(cls) {
+ debugAssert(cls instanceof Function, "Expected a class definition");
+ let instance = instanceCache.get(cls);
+ if (instance) {
+ debugAssert(instance instanceof cls, "Instance stored in cache mismatched with class");
+ return instance;
+ }
+ instance = new cls();
+ instanceCache.set(cls, instance);
+ return instance;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function initializeAuth(app2, deps) {
+ const provider2 = _getProvider(app2, "auth");
+ if (provider2.isInitialized()) {
+ const auth3 = provider2.getImmediate();
+ const initialOptions = provider2.getOptions();
+ if (deepEqual(initialOptions, deps !== null && deps !== void 0 ? deps : {})) {
+ return auth3;
+ } else {
+ _fail(auth3, "already-initialized");
+ }
+ }
+ const auth2 = provider2.initialize({ options: deps });
+ return auth2;
+}
+function _initializeAuthInstance(auth2, deps) {
+ const persistence = (deps === null || deps === void 0 ? void 0 : deps.persistence) || [];
+ const hierarchy = (Array.isArray(persistence) ? persistence : [persistence]).map(_getInstance);
+ if (deps === null || deps === void 0 ? void 0 : deps.errorMap) {
+ auth2._updateErrorMap(deps.errorMap);
+ }
+ auth2._initializeWithPersistence(hierarchy, deps === null || deps === void 0 ? void 0 : deps.popupRedirectResolver);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _getCurrentUrl() {
+ var _a2;
+ return typeof self !== "undefined" && ((_a2 = self.location) === null || _a2 === void 0 ? void 0 : _a2.href) || "";
+}
+function _isHttpOrHttps() {
+ return _getCurrentScheme() === "http:" || _getCurrentScheme() === "https:";
+}
+function _getCurrentScheme() {
+ var _a2;
+ return typeof self !== "undefined" && ((_a2 = self.location) === null || _a2 === void 0 ? void 0 : _a2.protocol) || null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _isOnline() {
+ if (typeof navigator !== "undefined" && navigator && "onLine" in navigator && typeof navigator.onLine === "boolean" && (_isHttpOrHttps() || isBrowserExtension() || "connection" in navigator)) {
+ return navigator.onLine;
+ }
+ return true;
+}
+function _getUserLanguage() {
+ if (typeof navigator === "undefined") {
+ return null;
+ }
+ const navigatorLanguage = navigator;
+ return navigatorLanguage.languages && navigatorLanguage.languages[0] || navigatorLanguage.language || null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Delay {
+ constructor(shortDelay, longDelay) {
+ this.shortDelay = shortDelay;
+ this.longDelay = longDelay;
+ debugAssert(longDelay > shortDelay, "Short delay should be less than long delay!");
+ this.isMobile = isMobileCordova() || isReactNative();
+ }
+ get() {
+ if (!_isOnline()) {
+ return Math.min(5e3, this.shortDelay);
+ }
+ return this.isMobile ? this.longDelay : this.shortDelay;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _emulatorUrl(config, path) {
+ debugAssert(config.emulator, "Emulator should always be set here");
+ const { url } = config.emulator;
+ if (!path) {
+ return url;
+ }
+ return `${url}${path.startsWith("/") ? path.slice(1) : path}`;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FetchProvider {
+ static initialize(fetchImpl, headersImpl, responseImpl) {
+ this.fetchImpl = fetchImpl;
+ if (headersImpl) {
+ this.headersImpl = headersImpl;
+ }
+ if (responseImpl) {
+ this.responseImpl = responseImpl;
+ }
+ }
+ static fetch() {
+ if (this.fetchImpl) {
+ return this.fetchImpl;
+ }
+ if (typeof self !== "undefined" && "fetch" in self) {
+ return self.fetch;
+ }
+ debugFail("Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+ }
+ static headers() {
+ if (this.headersImpl) {
+ return this.headersImpl;
+ }
+ if (typeof self !== "undefined" && "Headers" in self) {
+ return self.Headers;
+ }
+ debugFail("Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+ }
+ static response() {
+ if (this.responseImpl) {
+ return this.responseImpl;
+ }
+ if (typeof self !== "undefined" && "Response" in self) {
+ return self.Response;
+ }
+ debugFail("Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const SERVER_ERROR_MAP = {
+ ["CREDENTIAL_MISMATCH"]: "custom-token-mismatch",
+ ["MISSING_CUSTOM_TOKEN"]: "internal-error",
+ ["INVALID_IDENTIFIER"]: "invalid-email",
+ ["MISSING_CONTINUE_URI"]: "internal-error",
+ ["INVALID_PASSWORD"]: "wrong-password",
+ ["MISSING_PASSWORD"]: "missing-password",
+ ["EMAIL_EXISTS"]: "email-already-in-use",
+ ["PASSWORD_LOGIN_DISABLED"]: "operation-not-allowed",
+ ["INVALID_IDP_RESPONSE"]: "invalid-credential",
+ ["INVALID_PENDING_TOKEN"]: "invalid-credential",
+ ["FEDERATED_USER_ID_ALREADY_LINKED"]: "credential-already-in-use",
+ ["MISSING_REQ_TYPE"]: "internal-error",
+ ["EMAIL_NOT_FOUND"]: "user-not-found",
+ ["RESET_PASSWORD_EXCEED_LIMIT"]: "too-many-requests",
+ ["EXPIRED_OOB_CODE"]: "expired-action-code",
+ ["INVALID_OOB_CODE"]: "invalid-action-code",
+ ["MISSING_OOB_CODE"]: "internal-error",
+ ["CREDENTIAL_TOO_OLD_LOGIN_AGAIN"]: "requires-recent-login",
+ ["INVALID_ID_TOKEN"]: "invalid-user-token",
+ ["TOKEN_EXPIRED"]: "user-token-expired",
+ ["USER_NOT_FOUND"]: "user-token-expired",
+ ["TOO_MANY_ATTEMPTS_TRY_LATER"]: "too-many-requests",
+ ["INVALID_CODE"]: "invalid-verification-code",
+ ["INVALID_SESSION_INFO"]: "invalid-verification-id",
+ ["INVALID_TEMPORARY_PROOF"]: "invalid-credential",
+ ["MISSING_SESSION_INFO"]: "missing-verification-id",
+ ["SESSION_EXPIRED"]: "code-expired",
+ ["MISSING_ANDROID_PACKAGE_NAME"]: "missing-android-pkg-name",
+ ["UNAUTHORIZED_DOMAIN"]: "unauthorized-continue-uri",
+ ["INVALID_OAUTH_CLIENT_ID"]: "invalid-oauth-client-id",
+ ["ADMIN_ONLY_OPERATION"]: "admin-restricted-operation",
+ ["INVALID_MFA_PENDING_CREDENTIAL"]: "invalid-multi-factor-session",
+ ["MFA_ENROLLMENT_NOT_FOUND"]: "multi-factor-info-not-found",
+ ["MISSING_MFA_ENROLLMENT_ID"]: "missing-multi-factor-info",
+ ["MISSING_MFA_PENDING_CREDENTIAL"]: "missing-multi-factor-session",
+ ["SECOND_FACTOR_EXISTS"]: "second-factor-already-in-use",
+ ["SECOND_FACTOR_LIMIT_EXCEEDED"]: "maximum-second-factor-count-exceeded",
+ ["BLOCKING_FUNCTION_ERROR_RESPONSE"]: "internal-error"
+};
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_API_TIMEOUT_MS = new Delay(3e4, 6e4);
+function _addTidIfNecessary(auth2, request) {
+ if (auth2.tenantId && !request.tenantId) {
+ return Object.assign(Object.assign({}, request), { tenantId: auth2.tenantId });
+ }
+ return request;
+}
+async function _performApiRequest(auth2, method, path, request, customErrorMap = {}) {
+ return _performFetchWithErrorHandling(auth2, customErrorMap, async () => {
+ let body = {};
+ let params = {};
+ if (request) {
+ if (method === "GET") {
+ params = request;
+ } else {
+ body = {
+ body: JSON.stringify(request)
+ };
+ }
+ }
+ const query = querystring(Object.assign({ key: auth2.config.apiKey }, params)).slice(1);
+ const headers = await auth2._getAdditionalHeaders();
+ headers["Content-Type"] = "application/json";
+ if (auth2.languageCode) {
+ headers["X-Firebase-Locale"] = auth2.languageCode;
+ }
+ return FetchProvider.fetch()(_getFinalTarget(auth2, auth2.config.apiHost, path, query), Object.assign({
+ method,
+ headers,
+ referrerPolicy: "no-referrer"
+ }, body));
+ });
+}
+async function _performFetchWithErrorHandling(auth2, customErrorMap, fetchFn) {
+ auth2._canInitEmulator = false;
+ const errorMap = Object.assign(Object.assign({}, SERVER_ERROR_MAP), customErrorMap);
+ try {
+ const networkTimeout = new NetworkTimeout(auth2);
+ const response = await Promise.race([
+ fetchFn(),
+ networkTimeout.promise
+ ]);
+ networkTimeout.clearNetworkTimeout();
+ const json = await response.json();
+ if ("needConfirmation" in json) {
+ throw _makeTaggedError(auth2, "account-exists-with-different-credential", json);
+ }
+ if (response.ok && !("errorMessage" in json)) {
+ return json;
+ } else {
+ const errorMessage = response.ok ? json.errorMessage : json.error.message;
+ const [serverErrorCode, serverErrorMessage] = errorMessage.split(" : ");
+ if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED") {
+ throw _makeTaggedError(auth2, "credential-already-in-use", json);
+ } else if (serverErrorCode === "EMAIL_EXISTS") {
+ throw _makeTaggedError(auth2, "email-already-in-use", json);
+ } else if (serverErrorCode === "USER_DISABLED") {
+ throw _makeTaggedError(auth2, "user-disabled", json);
+ }
+ const authError = errorMap[serverErrorCode] || serverErrorCode.toLowerCase().replace(/[_\s]+/g, "-");
+ if (serverErrorMessage) {
+ throw _errorWithCustomMessage(auth2, authError, serverErrorMessage);
+ } else {
+ _fail(auth2, authError);
+ }
+ }
+ } catch (e) {
+ if (e instanceof FirebaseError) {
+ throw e;
+ }
+ _fail(auth2, "network-request-failed", { "message": String(e) });
+ }
+}
+async function _performSignInRequest(auth2, method, path, request, customErrorMap = {}) {
+ const serverResponse = await _performApiRequest(auth2, method, path, request, customErrorMap);
+ if ("mfaPendingCredential" in serverResponse) {
+ _fail(auth2, "multi-factor-auth-required", {
+ _serverResponse: serverResponse
+ });
+ }
+ return serverResponse;
+}
+function _getFinalTarget(auth2, host, path, query) {
+ const base = `${host}${path}?${query}`;
+ if (!auth2.config.emulator) {
+ return `${auth2.config.apiScheme}://${base}`;
+ }
+ return _emulatorUrl(auth2.config, base);
+}
+class NetworkTimeout {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.timer = null;
+ this.promise = new Promise((_, reject) => {
+ this.timer = setTimeout(() => {
+ return reject(_createError(this.auth, "network-request-failed"));
+ }, DEFAULT_API_TIMEOUT_MS.get());
+ });
+ }
+ clearNetworkTimeout() {
+ clearTimeout(this.timer);
+ }
+}
+function _makeTaggedError(auth2, code, response) {
+ const errorParams = {
+ appName: auth2.name
+ };
+ if (response.email) {
+ errorParams.email = response.email;
+ }
+ if (response.phoneNumber) {
+ errorParams.phoneNumber = response.phoneNumber;
+ }
+ const error = _createError(auth2, code, errorParams);
+ error.customData._tokenResponse = response;
+ return error;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function deleteAccount(auth2, request) {
+ return _performApiRequest(auth2, "POST", "/v1/accounts:delete", request);
+}
+async function getAccountInfo(auth2, request) {
+ return _performApiRequest(auth2, "POST", "/v1/accounts:lookup", request);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function utcTimestampToDateString(utcTimestamp) {
+ if (!utcTimestamp) {
+ return void 0;
+ }
+ try {
+ const date = new Date(Number(utcTimestamp));
+ if (!isNaN(date.getTime())) {
+ return date.toUTCString();
+ }
+ } catch (e) {
+ }
+ return void 0;
+}
+async function getIdTokenResult(user, forceRefresh = false) {
+ const userInternal = getModularInstance(user);
+ const token = await userInternal.getIdToken(forceRefresh);
+ const claims = _parseToken(token);
+ _assert(claims && claims.exp && claims.auth_time && claims.iat, userInternal.auth, "internal-error");
+ const firebase = typeof claims.firebase === "object" ? claims.firebase : void 0;
+ const signInProvider = firebase === null || firebase === void 0 ? void 0 : firebase["sign_in_provider"];
+ return {
+ claims,
+ token,
+ authTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.auth_time)),
+ issuedAtTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.iat)),
+ expirationTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.exp)),
+ signInProvider: signInProvider || null,
+ signInSecondFactor: (firebase === null || firebase === void 0 ? void 0 : firebase["sign_in_second_factor"]) || null
+ };
+}
+function secondsStringToMilliseconds(seconds) {
+ return Number(seconds) * 1e3;
+}
+function _parseToken(token) {
+ const [algorithm, payload, signature] = token.split(".");
+ if (algorithm === void 0 || payload === void 0 || signature === void 0) {
+ _logError("JWT malformed, contained fewer than 3 sections");
+ return null;
+ }
+ try {
+ const decoded = base64Decode(payload);
+ if (!decoded) {
+ _logError("Failed to decode base64 JWT payload");
+ return null;
+ }
+ return JSON.parse(decoded);
+ } catch (e) {
+ _logError("Caught error parsing JWT payload as JSON", e === null || e === void 0 ? void 0 : e.toString());
+ return null;
+ }
+}
+function _tokenExpiresIn(token) {
+ const parsedToken = _parseToken(token);
+ _assert(parsedToken, "internal-error");
+ _assert(typeof parsedToken.exp !== "undefined", "internal-error");
+ _assert(typeof parsedToken.iat !== "undefined", "internal-error");
+ return Number(parsedToken.exp) - Number(parsedToken.iat);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _logoutIfInvalidated(user, promise, bypassAuthState = false) {
+ if (bypassAuthState) {
+ return promise;
+ }
+ try {
+ return await promise;
+ } catch (e) {
+ if (e instanceof FirebaseError && isUserInvalidated(e)) {
+ if (user.auth.currentUser === user) {
+ await user.auth.signOut();
+ }
+ }
+ throw e;
+ }
+}
+function isUserInvalidated({ code }) {
+ return code === `auth/${"user-disabled"}` || code === `auth/${"user-token-expired"}`;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ProactiveRefresh {
+ constructor(user) {
+ this.user = user;
+ this.isRunning = false;
+ this.timerId = null;
+ this.errorBackoff = 3e4;
+ }
+ _start() {
+ if (this.isRunning) {
+ return;
+ }
+ this.isRunning = true;
+ this.schedule();
+ }
+ _stop() {
+ if (!this.isRunning) {
+ return;
+ }
+ this.isRunning = false;
+ if (this.timerId !== null) {
+ clearTimeout(this.timerId);
+ }
+ }
+ getInterval(wasError) {
+ var _a2;
+ if (wasError) {
+ const interval = this.errorBackoff;
+ this.errorBackoff = Math.min(this.errorBackoff * 2, 96e4);
+ return interval;
+ } else {
+ this.errorBackoff = 3e4;
+ const expTime = (_a2 = this.user.stsTokenManager.expirationTime) !== null && _a2 !== void 0 ? _a2 : 0;
+ const interval = expTime - Date.now() - 3e5;
+ return Math.max(0, interval);
+ }
+ }
+ schedule(wasError = false) {
+ if (!this.isRunning) {
+ return;
+ }
+ const interval = this.getInterval(wasError);
+ this.timerId = setTimeout(async () => {
+ await this.iteration();
+ }, interval);
+ }
+ async iteration() {
+ try {
+ await this.user.getIdToken(true);
+ } catch (e) {
+ if ((e === null || e === void 0 ? void 0 : e.code) === `auth/${"network-request-failed"}`) {
+ this.schedule(true);
+ }
+ return;
+ }
+ this.schedule();
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UserMetadata {
+ constructor(createdAt, lastLoginAt) {
+ this.createdAt = createdAt;
+ this.lastLoginAt = lastLoginAt;
+ this._initializeTime();
+ }
+ _initializeTime() {
+ this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);
+ this.creationTime = utcTimestampToDateString(this.createdAt);
+ }
+ _copy(metadata) {
+ this.createdAt = metadata.createdAt;
+ this.lastLoginAt = metadata.lastLoginAt;
+ this._initializeTime();
+ }
+ toJSON() {
+ return {
+ createdAt: this.createdAt,
+ lastLoginAt: this.lastLoginAt
+ };
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _reloadWithoutSaving(user) {
+ var _a2;
+ const auth2 = user.auth;
+ const idToken = await user.getIdToken();
+ const response = await _logoutIfInvalidated(user, getAccountInfo(auth2, { idToken }));
+ _assert(response === null || response === void 0 ? void 0 : response.users.length, auth2, "internal-error");
+ const coreAccount = response.users[0];
+ user._notifyReloadListener(coreAccount);
+ const newProviderData = ((_a2 = coreAccount.providerUserInfo) === null || _a2 === void 0 ? void 0 : _a2.length) ? extractProviderData(coreAccount.providerUserInfo) : [];
+ const providerData = mergeProviderData(user.providerData, newProviderData);
+ const oldIsAnonymous = user.isAnonymous;
+ const newIsAnonymous = !(user.email && coreAccount.passwordHash) && !(providerData === null || providerData === void 0 ? void 0 : providerData.length);
+ const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;
+ const updates = {
+ uid: coreAccount.localId,
+ displayName: coreAccount.displayName || null,
+ photoURL: coreAccount.photoUrl || null,
+ email: coreAccount.email || null,
+ emailVerified: coreAccount.emailVerified || false,
+ phoneNumber: coreAccount.phoneNumber || null,
+ tenantId: coreAccount.tenantId || null,
+ providerData,
+ metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),
+ isAnonymous
+ };
+ Object.assign(user, updates);
+}
+async function reload(user) {
+ const userInternal = getModularInstance(user);
+ await _reloadWithoutSaving(userInternal);
+ await userInternal.auth._persistUserIfCurrent(userInternal);
+ userInternal.auth._notifyListenersIfCurrent(userInternal);
+}
+function mergeProviderData(original, newData) {
+ const deduped = original.filter((o) => !newData.some((n) => n.providerId === o.providerId));
+ return [...deduped, ...newData];
+}
+function extractProviderData(providers) {
+ return providers.map((_a2) => {
+ var { providerId } = _a2, provider2 = __rest(_a2, ["providerId"]);
+ return {
+ providerId,
+ uid: provider2.rawId || "",
+ displayName: provider2.displayName || null,
+ email: provider2.email || null,
+ phoneNumber: provider2.phoneNumber || null,
+ photoURL: provider2.photoUrl || null
+ };
+ });
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function requestStsToken(auth2, refreshToken) {
+ const response = await _performFetchWithErrorHandling(auth2, {}, async () => {
+ const body = querystring({
+ "grant_type": "refresh_token",
+ "refresh_token": refreshToken
+ }).slice(1);
+ const { tokenApiHost, apiKey } = auth2.config;
+ const url = _getFinalTarget(auth2, tokenApiHost, "/v1/token", `key=${apiKey}`);
+ const headers = await auth2._getAdditionalHeaders();
+ headers["Content-Type"] = "application/x-www-form-urlencoded";
+ return FetchProvider.fetch()(url, {
+ method: "POST",
+ headers,
+ body
+ });
+ });
+ return {
+ accessToken: response.access_token,
+ expiresIn: response.expires_in,
+ refreshToken: response.refresh_token
+ };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class StsTokenManager {
+ constructor() {
+ this.refreshToken = null;
+ this.accessToken = null;
+ this.expirationTime = null;
+ }
+ get isExpired() {
+ return !this.expirationTime || Date.now() > this.expirationTime - 3e4;
+ }
+ updateFromServerResponse(response) {
+ _assert(response.idToken, "internal-error");
+ _assert(typeof response.idToken !== "undefined", "internal-error");
+ _assert(typeof response.refreshToken !== "undefined", "internal-error");
+ const expiresIn = "expiresIn" in response && typeof response.expiresIn !== "undefined" ? Number(response.expiresIn) : _tokenExpiresIn(response.idToken);
+ this.updateTokensAndExpiration(response.idToken, response.refreshToken, expiresIn);
+ }
+ async getToken(auth2, forceRefresh = false) {
+ _assert(!this.accessToken || this.refreshToken, auth2, "user-token-expired");
+ if (!forceRefresh && this.accessToken && !this.isExpired) {
+ return this.accessToken;
+ }
+ if (this.refreshToken) {
+ await this.refresh(auth2, this.refreshToken);
+ return this.accessToken;
+ }
+ return null;
+ }
+ clearRefreshToken() {
+ this.refreshToken = null;
+ }
+ async refresh(auth2, oldToken) {
+ const { accessToken, refreshToken, expiresIn } = await requestStsToken(auth2, oldToken);
+ this.updateTokensAndExpiration(accessToken, refreshToken, Number(expiresIn));
+ }
+ updateTokensAndExpiration(accessToken, refreshToken, expiresInSec) {
+ this.refreshToken = refreshToken || null;
+ this.accessToken = accessToken || null;
+ this.expirationTime = Date.now() + expiresInSec * 1e3;
+ }
+ static fromJSON(appName, object) {
+ const { refreshToken, accessToken, expirationTime } = object;
+ const manager = new StsTokenManager();
+ if (refreshToken) {
+ _assert(typeof refreshToken === "string", "internal-error", {
+ appName
+ });
+ manager.refreshToken = refreshToken;
+ }
+ if (accessToken) {
+ _assert(typeof accessToken === "string", "internal-error", {
+ appName
+ });
+ manager.accessToken = accessToken;
+ }
+ if (expirationTime) {
+ _assert(typeof expirationTime === "number", "internal-error", {
+ appName
+ });
+ manager.expirationTime = expirationTime;
+ }
+ return manager;
+ }
+ toJSON() {
+ return {
+ refreshToken: this.refreshToken,
+ accessToken: this.accessToken,
+ expirationTime: this.expirationTime
+ };
+ }
+ _assign(stsTokenManager) {
+ this.accessToken = stsTokenManager.accessToken;
+ this.refreshToken = stsTokenManager.refreshToken;
+ this.expirationTime = stsTokenManager.expirationTime;
+ }
+ _clone() {
+ return Object.assign(new StsTokenManager(), this.toJSON());
+ }
+ _performRefresh() {
+ return debugFail("not implemented");
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function assertStringOrUndefined(assertion, appName) {
+ _assert(typeof assertion === "string" || typeof assertion === "undefined", "internal-error", { appName });
+}
+class UserImpl {
+ constructor(_a2) {
+ var { uid, auth: auth2, stsTokenManager } = _a2, opt = __rest(_a2, ["uid", "auth", "stsTokenManager"]);
+ this.providerId = "firebase";
+ this.proactiveRefresh = new ProactiveRefresh(this);
+ this.reloadUserInfo = null;
+ this.reloadListener = null;
+ this.uid = uid;
+ this.auth = auth2;
+ this.stsTokenManager = stsTokenManager;
+ this.accessToken = stsTokenManager.accessToken;
+ this.displayName = opt.displayName || null;
+ this.email = opt.email || null;
+ this.emailVerified = opt.emailVerified || false;
+ this.phoneNumber = opt.phoneNumber || null;
+ this.photoURL = opt.photoURL || null;
+ this.isAnonymous = opt.isAnonymous || false;
+ this.tenantId = opt.tenantId || null;
+ this.providerData = opt.providerData ? [...opt.providerData] : [];
+ this.metadata = new UserMetadata(opt.createdAt || void 0, opt.lastLoginAt || void 0);
+ }
+ async getIdToken(forceRefresh) {
+ const accessToken = await _logoutIfInvalidated(this, this.stsTokenManager.getToken(this.auth, forceRefresh));
+ _assert(accessToken, this.auth, "internal-error");
+ if (this.accessToken !== accessToken) {
+ this.accessToken = accessToken;
+ await this.auth._persistUserIfCurrent(this);
+ this.auth._notifyListenersIfCurrent(this);
+ }
+ return accessToken;
+ }
+ getIdTokenResult(forceRefresh) {
+ return getIdTokenResult(this, forceRefresh);
+ }
+ reload() {
+ return reload(this);
+ }
+ _assign(user) {
+ if (this === user) {
+ return;
+ }
+ _assert(this.uid === user.uid, this.auth, "internal-error");
+ this.displayName = user.displayName;
+ this.photoURL = user.photoURL;
+ this.email = user.email;
+ this.emailVerified = user.emailVerified;
+ this.phoneNumber = user.phoneNumber;
+ this.isAnonymous = user.isAnonymous;
+ this.tenantId = user.tenantId;
+ this.providerData = user.providerData.map((userInfo) => Object.assign({}, userInfo));
+ this.metadata._copy(user.metadata);
+ this.stsTokenManager._assign(user.stsTokenManager);
+ }
+ _clone(auth2) {
+ const newUser = new UserImpl(Object.assign(Object.assign({}, this), { auth: auth2, stsTokenManager: this.stsTokenManager._clone() }));
+ newUser.metadata._copy(this.metadata);
+ return newUser;
+ }
+ _onReload(callback) {
+ _assert(!this.reloadListener, this.auth, "internal-error");
+ this.reloadListener = callback;
+ if (this.reloadUserInfo) {
+ this._notifyReloadListener(this.reloadUserInfo);
+ this.reloadUserInfo = null;
+ }
+ }
+ _notifyReloadListener(userInfo) {
+ if (this.reloadListener) {
+ this.reloadListener(userInfo);
+ } else {
+ this.reloadUserInfo = userInfo;
+ }
+ }
+ _startProactiveRefresh() {
+ this.proactiveRefresh._start();
+ }
+ _stopProactiveRefresh() {
+ this.proactiveRefresh._stop();
+ }
+ async _updateTokensIfNecessary(response, reload2 = false) {
+ let tokensRefreshed = false;
+ if (response.idToken && response.idToken !== this.stsTokenManager.accessToken) {
+ this.stsTokenManager.updateFromServerResponse(response);
+ tokensRefreshed = true;
+ }
+ if (reload2) {
+ await _reloadWithoutSaving(this);
+ }
+ await this.auth._persistUserIfCurrent(this);
+ if (tokensRefreshed) {
+ this.auth._notifyListenersIfCurrent(this);
+ }
+ }
+ async delete() {
+ const idToken = await this.getIdToken();
+ await _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken }));
+ this.stsTokenManager.clearRefreshToken();
+ return this.auth.signOut();
+ }
+ toJSON() {
+ return Object.assign(Object.assign({
+ uid: this.uid,
+ email: this.email || void 0,
+ emailVerified: this.emailVerified,
+ displayName: this.displayName || void 0,
+ isAnonymous: this.isAnonymous,
+ photoURL: this.photoURL || void 0,
+ phoneNumber: this.phoneNumber || void 0,
+ tenantId: this.tenantId || void 0,
+ providerData: this.providerData.map((userInfo) => Object.assign({}, userInfo)),
+ stsTokenManager: this.stsTokenManager.toJSON(),
+ _redirectEventId: this._redirectEventId
+ }, this.metadata.toJSON()), {
+ apiKey: this.auth.config.apiKey,
+ appName: this.auth.name
+ });
+ }
+ get refreshToken() {
+ return this.stsTokenManager.refreshToken || "";
+ }
+ static _fromJSON(auth2, object) {
+ var _a2, _b, _c2, _d, _e2, _f, _g, _h2;
+ const displayName = (_a2 = object.displayName) !== null && _a2 !== void 0 ? _a2 : void 0;
+ const email = (_b = object.email) !== null && _b !== void 0 ? _b : void 0;
+ const phoneNumber = (_c2 = object.phoneNumber) !== null && _c2 !== void 0 ? _c2 : void 0;
+ const photoURL = (_d = object.photoURL) !== null && _d !== void 0 ? _d : void 0;
+ const tenantId = (_e2 = object.tenantId) !== null && _e2 !== void 0 ? _e2 : void 0;
+ const _redirectEventId = (_f = object._redirectEventId) !== null && _f !== void 0 ? _f : void 0;
+ const createdAt = (_g = object.createdAt) !== null && _g !== void 0 ? _g : void 0;
+ const lastLoginAt = (_h2 = object.lastLoginAt) !== null && _h2 !== void 0 ? _h2 : void 0;
+ const { uid, emailVerified, isAnonymous, providerData, stsTokenManager: plainObjectTokenManager } = object;
+ _assert(uid && plainObjectTokenManager, auth2, "internal-error");
+ const stsTokenManager = StsTokenManager.fromJSON(this.name, plainObjectTokenManager);
+ _assert(typeof uid === "string", auth2, "internal-error");
+ assertStringOrUndefined(displayName, auth2.name);
+ assertStringOrUndefined(email, auth2.name);
+ _assert(typeof emailVerified === "boolean", auth2, "internal-error");
+ _assert(typeof isAnonymous === "boolean", auth2, "internal-error");
+ assertStringOrUndefined(phoneNumber, auth2.name);
+ assertStringOrUndefined(photoURL, auth2.name);
+ assertStringOrUndefined(tenantId, auth2.name);
+ assertStringOrUndefined(_redirectEventId, auth2.name);
+ assertStringOrUndefined(createdAt, auth2.name);
+ assertStringOrUndefined(lastLoginAt, auth2.name);
+ const user = new UserImpl({
+ uid,
+ auth: auth2,
+ email,
+ emailVerified,
+ displayName,
+ isAnonymous,
+ photoURL,
+ phoneNumber,
+ tenantId,
+ stsTokenManager,
+ createdAt,
+ lastLoginAt
+ });
+ if (providerData && Array.isArray(providerData)) {
+ user.providerData = providerData.map((userInfo) => Object.assign({}, userInfo));
+ }
+ if (_redirectEventId) {
+ user._redirectEventId = _redirectEventId;
+ }
+ return user;
+ }
+ static async _fromIdTokenResponse(auth2, idTokenResponse, isAnonymous = false) {
+ const stsTokenManager = new StsTokenManager();
+ stsTokenManager.updateFromServerResponse(idTokenResponse);
+ const user = new UserImpl({
+ uid: idTokenResponse.localId,
+ auth: auth2,
+ stsTokenManager,
+ isAnonymous
+ });
+ await _reloadWithoutSaving(user);
+ return user;
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class InMemoryPersistence {
+ constructor() {
+ this.type = "NONE";
+ this.storage = {};
+ }
+ async _isAvailable() {
+ return true;
+ }
+ async _set(key, value) {
+ this.storage[key] = value;
+ }
+ async _get(key) {
+ const value = this.storage[key];
+ return value === void 0 ? null : value;
+ }
+ async _remove(key) {
+ delete this.storage[key];
+ }
+ _addListener(_key, _listener) {
+ return;
+ }
+ _removeListener(_key, _listener) {
+ return;
+ }
+}
+InMemoryPersistence.type = "NONE";
+const inMemoryPersistence = InMemoryPersistence;
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _persistenceKeyName(key, apiKey, appName) {
+ return `${"firebase"}:${key}:${apiKey}:${appName}`;
+}
+class PersistenceUserManager {
+ constructor(persistence, auth2, userKey) {
+ this.persistence = persistence;
+ this.auth = auth2;
+ this.userKey = userKey;
+ const { config, name: name2 } = this.auth;
+ this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name2);
+ this.fullPersistenceKey = _persistenceKeyName("persistence", config.apiKey, name2);
+ this.boundEventHandler = auth2._onStorageEvent.bind(auth2);
+ this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
+ }
+ setCurrentUser(user) {
+ return this.persistence._set(this.fullUserKey, user.toJSON());
+ }
+ async getCurrentUser() {
+ const blob = await this.persistence._get(this.fullUserKey);
+ return blob ? UserImpl._fromJSON(this.auth, blob) : null;
+ }
+ removeCurrentUser() {
+ return this.persistence._remove(this.fullUserKey);
+ }
+ savePersistenceForRedirect() {
+ return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
+ }
+ async setPersistence(newPersistence) {
+ if (this.persistence === newPersistence) {
+ return;
+ }
+ const currentUser = await this.getCurrentUser();
+ await this.removeCurrentUser();
+ this.persistence = newPersistence;
+ if (currentUser) {
+ return this.setCurrentUser(currentUser);
+ }
+ }
+ delete() {
+ this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
+ }
+ static async create(auth2, persistenceHierarchy, userKey = "authUser") {
+ if (!persistenceHierarchy.length) {
+ return new PersistenceUserManager(_getInstance(inMemoryPersistence), auth2, userKey);
+ }
+ const availablePersistences = (await Promise.all(persistenceHierarchy.map(async (persistence) => {
+ if (await persistence._isAvailable()) {
+ return persistence;
+ }
+ return void 0;
+ }))).filter((persistence) => persistence);
+ let selectedPersistence = availablePersistences[0] || _getInstance(inMemoryPersistence);
+ const key = _persistenceKeyName(userKey, auth2.config.apiKey, auth2.name);
+ let userToMigrate = null;
+ for (const persistence of persistenceHierarchy) {
+ try {
+ const blob = await persistence._get(key);
+ if (blob) {
+ const user = UserImpl._fromJSON(auth2, blob);
+ if (persistence !== selectedPersistence) {
+ userToMigrate = user;
+ }
+ selectedPersistence = persistence;
+ break;
+ }
+ } catch (_a2) {
+ }
+ }
+ const migrationHierarchy = availablePersistences.filter((p2) => p2._shouldAllowMigration);
+ if (!selectedPersistence._shouldAllowMigration || !migrationHierarchy.length) {
+ return new PersistenceUserManager(selectedPersistence, auth2, userKey);
+ }
+ selectedPersistence = migrationHierarchy[0];
+ if (userToMigrate) {
+ await selectedPersistence._set(key, userToMigrate.toJSON());
+ }
+ await Promise.all(persistenceHierarchy.map(async (persistence) => {
+ if (persistence !== selectedPersistence) {
+ try {
+ await persistence._remove(key);
+ } catch (_a2) {
+ }
+ }
+ }));
+ return new PersistenceUserManager(selectedPersistence, auth2, userKey);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _getBrowserName(userAgent) {
+ const ua2 = userAgent.toLowerCase();
+ if (ua2.includes("opera/") || ua2.includes("opr/") || ua2.includes("opios/")) {
+ return "Opera";
+ } else if (_isIEMobile(ua2)) {
+ return "IEMobile";
+ } else if (ua2.includes("msie") || ua2.includes("trident/")) {
+ return "IE";
+ } else if (ua2.includes("edge/")) {
+ return "Edge";
+ } else if (_isFirefox(ua2)) {
+ return "Firefox";
+ } else if (ua2.includes("silk/")) {
+ return "Silk";
+ } else if (_isBlackBerry(ua2)) {
+ return "Blackberry";
+ } else if (_isWebOS(ua2)) {
+ return "Webos";
+ } else if (_isSafari(ua2)) {
+ return "Safari";
+ } else if ((ua2.includes("chrome/") || _isChromeIOS(ua2)) && !ua2.includes("edge/")) {
+ return "Chrome";
+ } else if (_isAndroid(ua2)) {
+ return "Android";
+ } else {
+ const re = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/;
+ const matches = userAgent.match(re);
+ if ((matches === null || matches === void 0 ? void 0 : matches.length) === 2) {
+ return matches[1];
+ }
+ }
+ return "Other";
+}
+function _isFirefox(ua2 = getUA()) {
+ return /firefox\//i.test(ua2);
+}
+function _isSafari(userAgent = getUA()) {
+ const ua2 = userAgent.toLowerCase();
+ return ua2.includes("safari/") && !ua2.includes("chrome/") && !ua2.includes("crios/") && !ua2.includes("android");
+}
+function _isChromeIOS(ua2 = getUA()) {
+ return /crios\//i.test(ua2);
+}
+function _isIEMobile(ua2 = getUA()) {
+ return /iemobile/i.test(ua2);
+}
+function _isAndroid(ua2 = getUA()) {
+ return /android/i.test(ua2);
+}
+function _isBlackBerry(ua2 = getUA()) {
+ return /blackberry/i.test(ua2);
+}
+function _isWebOS(ua2 = getUA()) {
+ return /webos/i.test(ua2);
+}
+function _isIOS(ua2 = getUA()) {
+ return /iphone|ipad|ipod/i.test(ua2) || /macintosh/i.test(ua2) && /mobile/i.test(ua2);
+}
+function _isIOSStandalone(ua2 = getUA()) {
+ var _a2;
+ return _isIOS(ua2) && !!((_a2 = window.navigator) === null || _a2 === void 0 ? void 0 : _a2.standalone);
+}
+function _isIE10() {
+ return isIE() && document.documentMode === 10;
+}
+function _isMobileBrowser(ua2 = getUA()) {
+ return _isIOS(ua2) || _isAndroid(ua2) || _isWebOS(ua2) || _isBlackBerry(ua2) || /windows phone/i.test(ua2) || _isIEMobile(ua2);
+}
+function _isIframe() {
+ try {
+ return !!(window && window !== window.top);
+ } catch (e) {
+ return false;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _getClientVersion(clientPlatform, frameworks = []) {
+ let reportedPlatform;
+ switch (clientPlatform) {
+ case "Browser":
+ reportedPlatform = _getBrowserName(getUA());
+ break;
+ case "Worker":
+ reportedPlatform = `${_getBrowserName(getUA())}-${clientPlatform}`;
+ break;
+ default:
+ reportedPlatform = clientPlatform;
+ }
+ const reportedFrameworks = frameworks.length ? frameworks.join(",") : "FirebaseCore-web";
+ return `${reportedPlatform}/${"JsCore"}/${SDK_VERSION}/${reportedFrameworks}`;
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthMiddlewareQueue {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.queue = [];
+ }
+ pushCallback(callback, onAbort) {
+ const wrappedCallback = (user) => new Promise((resolve, reject) => {
+ try {
+ const result = callback(user);
+ resolve(result);
+ } catch (e) {
+ reject(e);
+ }
+ });
+ wrappedCallback.onAbort = onAbort;
+ this.queue.push(wrappedCallback);
+ const index = this.queue.length - 1;
+ return () => {
+ this.queue[index] = () => Promise.resolve();
+ };
+ }
+ async runMiddleware(nextUser) {
+ if (this.auth.currentUser === nextUser) {
+ return;
+ }
+ const onAbortStack = [];
+ try {
+ for (const beforeStateCallback of this.queue) {
+ await beforeStateCallback(nextUser);
+ if (beforeStateCallback.onAbort) {
+ onAbortStack.push(beforeStateCallback.onAbort);
+ }
+ }
+ } catch (e) {
+ onAbortStack.reverse();
+ for (const onAbort of onAbortStack) {
+ try {
+ onAbort();
+ } catch (_) {
+ }
+ }
+ throw this.auth._errorFactory.create("login-blocked", {
+ originalMessage: e === null || e === void 0 ? void 0 : e.message
+ });
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthImpl {
+ constructor(app2, heartbeatServiceProvider, config) {
+ this.app = app2;
+ this.heartbeatServiceProvider = heartbeatServiceProvider;
+ this.config = config;
+ this.currentUser = null;
+ this.emulatorConfig = null;
+ this.operations = Promise.resolve();
+ this.authStateSubscription = new Subscription(this);
+ this.idTokenSubscription = new Subscription(this);
+ this.beforeStateQueue = new AuthMiddlewareQueue(this);
+ this.redirectUser = null;
+ this.isProactiveRefreshEnabled = false;
+ this._canInitEmulator = true;
+ this._isInitialized = false;
+ this._deleted = false;
+ this._initializationPromise = null;
+ this._popupRedirectResolver = null;
+ this._errorFactory = _DEFAULT_AUTH_ERROR_FACTORY;
+ this.lastNotifiedUid = void 0;
+ this.languageCode = null;
+ this.tenantId = null;
+ this.settings = { appVerificationDisabledForTesting: false };
+ this.frameworks = [];
+ this.name = app2.name;
+ this.clientVersion = config.sdkClientVersion;
+ }
+ _initializeWithPersistence(persistenceHierarchy, popupRedirectResolver) {
+ if (popupRedirectResolver) {
+ this._popupRedirectResolver = _getInstance(popupRedirectResolver);
+ }
+ this._initializationPromise = this.queue(async () => {
+ var _a2, _b;
+ if (this._deleted) {
+ return;
+ }
+ this.persistenceManager = await PersistenceUserManager.create(this, persistenceHierarchy);
+ if (this._deleted) {
+ return;
+ }
+ if ((_a2 = this._popupRedirectResolver) === null || _a2 === void 0 ? void 0 : _a2._shouldInitProactively) {
+ try {
+ await this._popupRedirectResolver._initialize(this);
+ } catch (e) {
+ }
+ }
+ await this.initializeCurrentUser(popupRedirectResolver);
+ this.lastNotifiedUid = ((_b = this.currentUser) === null || _b === void 0 ? void 0 : _b.uid) || null;
+ if (this._deleted) {
+ return;
+ }
+ this._isInitialized = true;
+ });
+ return this._initializationPromise;
+ }
+ async _onStorageEvent() {
+ if (this._deleted) {
+ return;
+ }
+ const user = await this.assertedPersistence.getCurrentUser();
+ if (!this.currentUser && !user) {
+ return;
+ }
+ if (this.currentUser && user && this.currentUser.uid === user.uid) {
+ this._currentUser._assign(user);
+ await this.currentUser.getIdToken();
+ return;
+ }
+ await this._updateCurrentUser(user, true);
+ }
+ async initializeCurrentUser(popupRedirectResolver) {
+ var _a2;
+ const previouslyStoredUser = await this.assertedPersistence.getCurrentUser();
+ let futureCurrentUser = previouslyStoredUser;
+ let needsTocheckMiddleware = false;
+ if (popupRedirectResolver && this.config.authDomain) {
+ await this.getOrInitRedirectPersistenceManager();
+ const redirectUserEventId = (_a2 = this.redirectUser) === null || _a2 === void 0 ? void 0 : _a2._redirectEventId;
+ const storedUserEventId = futureCurrentUser === null || futureCurrentUser === void 0 ? void 0 : futureCurrentUser._redirectEventId;
+ const result = await this.tryRedirectSignIn(popupRedirectResolver);
+ if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) && (result === null || result === void 0 ? void 0 : result.user)) {
+ futureCurrentUser = result.user;
+ needsTocheckMiddleware = true;
+ }
+ }
+ if (!futureCurrentUser) {
+ return this.directlySetCurrentUser(null);
+ }
+ if (!futureCurrentUser._redirectEventId) {
+ if (needsTocheckMiddleware) {
+ try {
+ await this.beforeStateQueue.runMiddleware(futureCurrentUser);
+ } catch (e) {
+ futureCurrentUser = previouslyStoredUser;
+ this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(e));
+ }
+ }
+ if (futureCurrentUser) {
+ return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
+ } else {
+ return this.directlySetCurrentUser(null);
+ }
+ }
+ _assert(this._popupRedirectResolver, this, "argument-error");
+ await this.getOrInitRedirectPersistenceManager();
+ if (this.redirectUser && this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
+ return this.directlySetCurrentUser(futureCurrentUser);
+ }
+ return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
+ }
+ async tryRedirectSignIn(redirectResolver) {
+ let result = null;
+ try {
+ result = await this._popupRedirectResolver._completeRedirectFn(this, redirectResolver, true);
+ } catch (e) {
+ await this._setRedirectUser(null);
+ }
+ return result;
+ }
+ async reloadAndSetCurrentUserOrClear(user) {
+ try {
+ await _reloadWithoutSaving(user);
+ } catch (e) {
+ if ((e === null || e === void 0 ? void 0 : e.code) !== `auth/${"network-request-failed"}`) {
+ return this.directlySetCurrentUser(null);
+ }
+ }
+ return this.directlySetCurrentUser(user);
+ }
+ useDeviceLanguage() {
+ this.languageCode = _getUserLanguage();
+ }
+ async _delete() {
+ this._deleted = true;
+ }
+ async updateCurrentUser(userExtern) {
+ const user = userExtern ? getModularInstance(userExtern) : null;
+ if (user) {
+ _assert(user.auth.config.apiKey === this.config.apiKey, this, "invalid-user-token");
+ }
+ return this._updateCurrentUser(user && user._clone(this));
+ }
+ async _updateCurrentUser(user, skipBeforeStateCallbacks = false) {
+ if (this._deleted) {
+ return;
+ }
+ if (user) {
+ _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch");
+ }
+ if (!skipBeforeStateCallbacks) {
+ await this.beforeStateQueue.runMiddleware(user);
+ }
+ return this.queue(async () => {
+ await this.directlySetCurrentUser(user);
+ this.notifyAuthListeners();
+ });
+ }
+ async signOut() {
+ await this.beforeStateQueue.runMiddleware(null);
+ if (this.redirectPersistenceManager || this._popupRedirectResolver) {
+ await this._setRedirectUser(null);
+ }
+ return this._updateCurrentUser(null, true);
+ }
+ setPersistence(persistence) {
+ return this.queue(async () => {
+ await this.assertedPersistence.setPersistence(_getInstance(persistence));
+ });
+ }
+ _getPersistence() {
+ return this.assertedPersistence.persistence.type;
+ }
+ _updateErrorMap(errorMap) {
+ this._errorFactory = new ErrorFactory("auth", "Firebase", errorMap());
+ }
+ onAuthStateChanged(nextOrObserver, error, completed) {
+ return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
+ }
+ beforeAuthStateChanged(callback, onAbort) {
+ return this.beforeStateQueue.pushCallback(callback, onAbort);
+ }
+ onIdTokenChanged(nextOrObserver, error, completed) {
+ return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
+ }
+ toJSON() {
+ var _a2;
+ return {
+ apiKey: this.config.apiKey,
+ authDomain: this.config.authDomain,
+ appName: this.name,
+ currentUser: (_a2 = this._currentUser) === null || _a2 === void 0 ? void 0 : _a2.toJSON()
+ };
+ }
+ async _setRedirectUser(user, popupRedirectResolver) {
+ const redirectManager = await this.getOrInitRedirectPersistenceManager(popupRedirectResolver);
+ return user === null ? redirectManager.removeCurrentUser() : redirectManager.setCurrentUser(user);
+ }
+ async getOrInitRedirectPersistenceManager(popupRedirectResolver) {
+ if (!this.redirectPersistenceManager) {
+ const resolver = popupRedirectResolver && _getInstance(popupRedirectResolver) || this._popupRedirectResolver;
+ _assert(resolver, this, "argument-error");
+ this.redirectPersistenceManager = await PersistenceUserManager.create(this, [_getInstance(resolver._redirectPersistence)], "redirectUser");
+ this.redirectUser = await this.redirectPersistenceManager.getCurrentUser();
+ }
+ return this.redirectPersistenceManager;
+ }
+ async _redirectUserForId(id2) {
+ var _a2, _b;
+ if (this._isInitialized) {
+ await this.queue(async () => {
+ });
+ }
+ if (((_a2 = this._currentUser) === null || _a2 === void 0 ? void 0 : _a2._redirectEventId) === id2) {
+ return this._currentUser;
+ }
+ if (((_b = this.redirectUser) === null || _b === void 0 ? void 0 : _b._redirectEventId) === id2) {
+ return this.redirectUser;
+ }
+ return null;
+ }
+ async _persistUserIfCurrent(user) {
+ if (user === this.currentUser) {
+ return this.queue(async () => this.directlySetCurrentUser(user));
+ }
+ }
+ _notifyListenersIfCurrent(user) {
+ if (user === this.currentUser) {
+ this.notifyAuthListeners();
+ }
+ }
+ _key() {
+ return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;
+ }
+ _startProactiveRefresh() {
+ this.isProactiveRefreshEnabled = true;
+ if (this.currentUser) {
+ this._currentUser._startProactiveRefresh();
+ }
+ }
+ _stopProactiveRefresh() {
+ this.isProactiveRefreshEnabled = false;
+ if (this.currentUser) {
+ this._currentUser._stopProactiveRefresh();
+ }
+ }
+ get _currentUser() {
+ return this.currentUser;
+ }
+ notifyAuthListeners() {
+ var _a2, _b;
+ if (!this._isInitialized) {
+ return;
+ }
+ this.idTokenSubscription.next(this.currentUser);
+ const currentUid = (_b = (_a2 = this.currentUser) === null || _a2 === void 0 ? void 0 : _a2.uid) !== null && _b !== void 0 ? _b : null;
+ if (this.lastNotifiedUid !== currentUid) {
+ this.lastNotifiedUid = currentUid;
+ this.authStateSubscription.next(this.currentUser);
+ }
+ }
+ registerStateListener(subscription, nextOrObserver, error, completed) {
+ if (this._deleted) {
+ return () => {
+ };
+ }
+ const cb2 = typeof nextOrObserver === "function" ? nextOrObserver : nextOrObserver.next.bind(nextOrObserver);
+ const promise = this._isInitialized ? Promise.resolve() : this._initializationPromise;
+ _assert(promise, this, "internal-error");
+ promise.then(() => cb2(this.currentUser));
+ if (typeof nextOrObserver === "function") {
+ return subscription.addObserver(nextOrObserver, error, completed);
+ } else {
+ return subscription.addObserver(nextOrObserver);
+ }
+ }
+ async directlySetCurrentUser(user) {
+ if (this.currentUser && this.currentUser !== user) {
+ this._currentUser._stopProactiveRefresh();
+ }
+ if (user && this.isProactiveRefreshEnabled) {
+ user._startProactiveRefresh();
+ }
+ this.currentUser = user;
+ if (user) {
+ await this.assertedPersistence.setCurrentUser(user);
+ } else {
+ await this.assertedPersistence.removeCurrentUser();
+ }
+ }
+ queue(action) {
+ this.operations = this.operations.then(action, action);
+ return this.operations;
+ }
+ get assertedPersistence() {
+ _assert(this.persistenceManager, this, "internal-error");
+ return this.persistenceManager;
+ }
+ _logFramework(framework) {
+ if (!framework || this.frameworks.includes(framework)) {
+ return;
+ }
+ this.frameworks.push(framework);
+ this.frameworks.sort();
+ this.clientVersion = _getClientVersion(this.config.clientPlatform, this._getFrameworks());
+ }
+ _getFrameworks() {
+ return this.frameworks;
+ }
+ async _getAdditionalHeaders() {
+ var _a2;
+ const headers = {
+ ["X-Client-Version"]: this.clientVersion
+ };
+ if (this.app.options.appId) {
+ headers["X-Firebase-gmpid"] = this.app.options.appId;
+ }
+ const heartbeatsHeader = await ((_a2 = this.heartbeatServiceProvider.getImmediate({
+ optional: true
+ })) === null || _a2 === void 0 ? void 0 : _a2.getHeartbeatsHeader());
+ if (heartbeatsHeader) {
+ headers["X-Firebase-Client"] = heartbeatsHeader;
+ }
+ return headers;
+ }
+}
+function _castAuth(auth2) {
+ return getModularInstance(auth2);
+}
+class Subscription {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.observer = null;
+ this.addObserver = createSubscribe((observer) => this.observer = observer);
+ }
+ get next() {
+ _assert(this.observer, this.auth, "internal-error");
+ return this.observer.next.bind(this.observer);
+ }
+}
+function connectAuthEmulator(auth2, url, options) {
+ const authInternal = _castAuth(auth2);
+ _assert(authInternal._canInitEmulator, authInternal, "emulator-config-failed");
+ _assert(/^https?:\/\//.test(url), authInternal, "invalid-emulator-scheme");
+ const disableWarnings = !!(options === null || options === void 0 ? void 0 : options.disableWarnings);
+ const protocol = extractProtocol(url);
+ const { host, port } = extractHostAndPort(url);
+ const portStr = port === null ? "" : `:${port}`;
+ authInternal.config.emulator = { url: `${protocol}//${host}${portStr}/` };
+ authInternal.settings.appVerificationDisabledForTesting = true;
+ authInternal.emulatorConfig = Object.freeze({
+ host,
+ port,
+ protocol: protocol.replace(":", ""),
+ options: Object.freeze({ disableWarnings })
+ });
+ if (!disableWarnings) {
+ emitEmulatorWarning();
+ }
+}
+function extractProtocol(url) {
+ const protocolEnd = url.indexOf(":");
+ return protocolEnd < 0 ? "" : url.substr(0, protocolEnd + 1);
+}
+function extractHostAndPort(url) {
+ const protocol = extractProtocol(url);
+ const authority = /(\/\/)?([^?#/]+)/.exec(url.substr(protocol.length));
+ if (!authority) {
+ return { host: "", port: null };
+ }
+ const hostAndPort = authority[2].split("@").pop() || "";
+ const bracketedIPv6 = /^(\[[^\]]+\])(:|$)/.exec(hostAndPort);
+ if (bracketedIPv6) {
+ const host = bracketedIPv6[1];
+ return { host, port: parsePort(hostAndPort.substr(host.length + 1)) };
+ } else {
+ const [host, port] = hostAndPort.split(":");
+ return { host, port: parsePort(port) };
+ }
+}
+function parsePort(portStr) {
+ if (!portStr) {
+ return null;
+ }
+ const port = Number(portStr);
+ if (isNaN(port)) {
+ return null;
+ }
+ return port;
+}
+function emitEmulatorWarning() {
+ function attachBanner() {
+ const el2 = document.createElement("p");
+ const sty = el2.style;
+ el2.innerText = "Running in emulator mode. Do not use with production credentials.";
+ sty.position = "fixed";
+ sty.width = "100%";
+ sty.backgroundColor = "#ffffff";
+ sty.border = ".1em solid #000000";
+ sty.color = "#b50000";
+ sty.bottom = "0px";
+ sty.left = "0px";
+ sty.margin = "0px";
+ sty.zIndex = "10000";
+ sty.textAlign = "center";
+ el2.classList.add("firebase-emulator-warning");
+ document.body.appendChild(el2);
+ }
+ if (typeof console !== "undefined" && typeof console.info === "function") {
+ console.info("WARNING: You are using the Auth Emulator, which is intended for local testing only. Do not use with production credentials.");
+ }
+ if (typeof window !== "undefined" && typeof document !== "undefined") {
+ if (document.readyState === "loading") {
+ window.addEventListener("DOMContentLoaded", attachBanner);
+ } else {
+ attachBanner();
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthCredential {
+ constructor(providerId, signInMethod) {
+ this.providerId = providerId;
+ this.signInMethod = signInMethod;
+ }
+ toJSON() {
+ return debugFail("not implemented");
+ }
+ _getIdTokenResponse(_auth) {
+ return debugFail("not implemented");
+ }
+ _linkToIdToken(_auth, _idToken) {
+ return debugFail("not implemented");
+ }
+ _getReauthenticationResolver(_auth) {
+ return debugFail("not implemented");
+ }
+}
+async function updateEmailPassword(auth2, request) {
+ return _performApiRequest(auth2, "POST", "/v1/accounts:update", request);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signInWithPassword(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithPassword", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signInWithEmailLink$1(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary(auth2, request));
+}
+async function signInWithEmailLinkForLinking(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class EmailAuthCredential extends AuthCredential {
+ constructor(_email, _password, signInMethod, _tenantId = null) {
+ super("password", signInMethod);
+ this._email = _email;
+ this._password = _password;
+ this._tenantId = _tenantId;
+ }
+ static _fromEmailAndPassword(email, password) {
+ return new EmailAuthCredential(email, password, "password");
+ }
+ static _fromEmailAndCode(email, oobCode, tenantId = null) {
+ return new EmailAuthCredential(email, oobCode, "emailLink", tenantId);
+ }
+ toJSON() {
+ return {
+ email: this._email,
+ password: this._password,
+ signInMethod: this.signInMethod,
+ tenantId: this._tenantId
+ };
+ }
+ static fromJSON(json) {
+ const obj = typeof json === "string" ? JSON.parse(json) : json;
+ if ((obj === null || obj === void 0 ? void 0 : obj.email) && (obj === null || obj === void 0 ? void 0 : obj.password)) {
+ if (obj.signInMethod === "password") {
+ return this._fromEmailAndPassword(obj.email, obj.password);
+ } else if (obj.signInMethod === "emailLink") {
+ return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);
+ }
+ }
+ return null;
+ }
+ async _getIdTokenResponse(auth2) {
+ switch (this.signInMethod) {
+ case "password":
+ return signInWithPassword(auth2, {
+ returnSecureToken: true,
+ email: this._email,
+ password: this._password
+ });
+ case "emailLink":
+ return signInWithEmailLink$1(auth2, {
+ email: this._email,
+ oobCode: this._password
+ });
+ default:
+ _fail(auth2, "internal-error");
+ }
+ }
+ async _linkToIdToken(auth2, idToken) {
+ switch (this.signInMethod) {
+ case "password":
+ return updateEmailPassword(auth2, {
+ idToken,
+ returnSecureToken: true,
+ email: this._email,
+ password: this._password
+ });
+ case "emailLink":
+ return signInWithEmailLinkForLinking(auth2, {
+ idToken,
+ email: this._email,
+ oobCode: this._password
+ });
+ default:
+ _fail(auth2, "internal-error");
+ }
+ }
+ _getReauthenticationResolver(auth2) {
+ return this._getIdTokenResponse(auth2);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signInWithIdp(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithIdp", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const IDP_REQUEST_URI$1 = "http://localhost";
+class OAuthCredential extends AuthCredential {
+ constructor() {
+ super(...arguments);
+ this.pendingToken = null;
+ }
+ static _fromParams(params) {
+ const cred = new OAuthCredential(params.providerId, params.signInMethod);
+ if (params.idToken || params.accessToken) {
+ if (params.idToken) {
+ cred.idToken = params.idToken;
+ }
+ if (params.accessToken) {
+ cred.accessToken = params.accessToken;
+ }
+ if (params.nonce && !params.pendingToken) {
+ cred.nonce = params.nonce;
+ }
+ if (params.pendingToken) {
+ cred.pendingToken = params.pendingToken;
+ }
+ } else if (params.oauthToken && params.oauthTokenSecret) {
+ cred.accessToken = params.oauthToken;
+ cred.secret = params.oauthTokenSecret;
+ } else {
+ _fail("argument-error");
+ }
+ return cred;
+ }
+ toJSON() {
+ return {
+ idToken: this.idToken,
+ accessToken: this.accessToken,
+ secret: this.secret,
+ nonce: this.nonce,
+ pendingToken: this.pendingToken,
+ providerId: this.providerId,
+ signInMethod: this.signInMethod
+ };
+ }
+ static fromJSON(json) {
+ const obj = typeof json === "string" ? JSON.parse(json) : json;
+ const { providerId, signInMethod } = obj, rest = __rest(obj, ["providerId", "signInMethod"]);
+ if (!providerId || !signInMethod) {
+ return null;
+ }
+ const cred = new OAuthCredential(providerId, signInMethod);
+ cred.idToken = rest.idToken || void 0;
+ cred.accessToken = rest.accessToken || void 0;
+ cred.secret = rest.secret;
+ cred.nonce = rest.nonce;
+ cred.pendingToken = rest.pendingToken || null;
+ return cred;
+ }
+ _getIdTokenResponse(auth2) {
+ const request = this.buildRequest();
+ return signInWithIdp(auth2, request);
+ }
+ _linkToIdToken(auth2, idToken) {
+ const request = this.buildRequest();
+ request.idToken = idToken;
+ return signInWithIdp(auth2, request);
+ }
+ _getReauthenticationResolver(auth2) {
+ const request = this.buildRequest();
+ request.autoCreate = false;
+ return signInWithIdp(auth2, request);
+ }
+ buildRequest() {
+ const request = {
+ requestUri: IDP_REQUEST_URI$1,
+ returnSecureToken: true
+ };
+ if (this.pendingToken) {
+ request.pendingToken = this.pendingToken;
+ } else {
+ const postBody = {};
+ if (this.idToken) {
+ postBody["id_token"] = this.idToken;
+ }
+ if (this.accessToken) {
+ postBody["access_token"] = this.accessToken;
+ }
+ if (this.secret) {
+ postBody["oauth_token_secret"] = this.secret;
+ }
+ postBody["providerId"] = this.providerId;
+ if (this.nonce && !this.pendingToken) {
+ postBody["nonce"] = this.nonce;
+ }
+ request.postBody = querystring(postBody);
+ }
+ return request;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function parseMode(mode) {
+ switch (mode) {
+ case "recoverEmail":
+ return "RECOVER_EMAIL";
+ case "resetPassword":
+ return "PASSWORD_RESET";
+ case "signIn":
+ return "EMAIL_SIGNIN";
+ case "verifyEmail":
+ return "VERIFY_EMAIL";
+ case "verifyAndChangeEmail":
+ return "VERIFY_AND_CHANGE_EMAIL";
+ case "revertSecondFactorAddition":
+ return "REVERT_SECOND_FACTOR_ADDITION";
+ default:
+ return null;
+ }
+}
+function parseDeepLink(url) {
+ const link = querystringDecode(extractQuerystring(url))["link"];
+ const doubleDeepLink = link ? querystringDecode(extractQuerystring(link))["deep_link_id"] : null;
+ const iOSDeepLink = querystringDecode(extractQuerystring(url))["deep_link_id"];
+ const iOSDoubleDeepLink = iOSDeepLink ? querystringDecode(extractQuerystring(iOSDeepLink))["link"] : null;
+ return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
+}
+class ActionCodeURL {
+ constructor(actionLink) {
+ var _a2, _b, _c2, _d, _e2, _f;
+ const searchParams = querystringDecode(extractQuerystring(actionLink));
+ const apiKey = (_a2 = searchParams["apiKey"]) !== null && _a2 !== void 0 ? _a2 : null;
+ const code = (_b = searchParams["oobCode"]) !== null && _b !== void 0 ? _b : null;
+ const operation = parseMode((_c2 = searchParams["mode"]) !== null && _c2 !== void 0 ? _c2 : null);
+ _assert(apiKey && code && operation, "argument-error");
+ this.apiKey = apiKey;
+ this.operation = operation;
+ this.code = code;
+ this.continueUrl = (_d = searchParams["continueUrl"]) !== null && _d !== void 0 ? _d : null;
+ this.languageCode = (_e2 = searchParams["languageCode"]) !== null && _e2 !== void 0 ? _e2 : null;
+ this.tenantId = (_f = searchParams["tenantId"]) !== null && _f !== void 0 ? _f : null;
+ }
+ static parseLink(link) {
+ const actionLink = parseDeepLink(link);
+ try {
+ return new ActionCodeURL(actionLink);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class EmailAuthProvider {
+ constructor() {
+ this.providerId = EmailAuthProvider.PROVIDER_ID;
+ }
+ static credential(email, password) {
+ return EmailAuthCredential._fromEmailAndPassword(email, password);
+ }
+ static credentialWithLink(email, emailLink) {
+ const actionCodeUrl = ActionCodeURL.parseLink(emailLink);
+ _assert(actionCodeUrl, "argument-error");
+ return EmailAuthCredential._fromEmailAndCode(email, actionCodeUrl.code, actionCodeUrl.tenantId);
+ }
+}
+EmailAuthProvider.PROVIDER_ID = "password";
+EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD = "password";
+EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD = "emailLink";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FederatedAuthProvider {
+ constructor(providerId) {
+ this.providerId = providerId;
+ this.defaultLanguageCode = null;
+ this.customParameters = {};
+ }
+ setDefaultLanguage(languageCode) {
+ this.defaultLanguageCode = languageCode;
+ }
+ setCustomParameters(customOAuthParameters) {
+ this.customParameters = customOAuthParameters;
+ return this;
+ }
+ getCustomParameters() {
+ return this.customParameters;
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class BaseOAuthProvider extends FederatedAuthProvider {
+ constructor() {
+ super(...arguments);
+ this.scopes = [];
+ }
+ addScope(scope) {
+ if (!this.scopes.includes(scope)) {
+ this.scopes.push(scope);
+ }
+ return this;
+ }
+ getScopes() {
+ return [...this.scopes];
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FacebookAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("facebook.com");
+ }
+ static credential(accessToken) {
+ return OAuthCredential._fromParams({
+ providerId: FacebookAuthProvider.PROVIDER_ID,
+ signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,
+ accessToken
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return FacebookAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return FacebookAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
+ return null;
+ }
+ if (!tokenResponse.oauthAccessToken) {
+ return null;
+ }
+ try {
+ return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD = "facebook.com";
+FacebookAuthProvider.PROVIDER_ID = "facebook.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class GoogleAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("google.com");
+ this.addScope("profile");
+ }
+ static credential(idToken, accessToken) {
+ return OAuthCredential._fromParams({
+ providerId: GoogleAuthProvider.PROVIDER_ID,
+ signInMethod: GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,
+ idToken,
+ accessToken
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return GoogleAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return GoogleAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse) {
+ return null;
+ }
+ const { oauthIdToken, oauthAccessToken } = tokenResponse;
+ if (!oauthIdToken && !oauthAccessToken) {
+ return null;
+ }
+ try {
+ return GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD = "google.com";
+GoogleAuthProvider.PROVIDER_ID = "google.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class GithubAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("github.com");
+ }
+ static credential(accessToken) {
+ return OAuthCredential._fromParams({
+ providerId: GithubAuthProvider.PROVIDER_ID,
+ signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,
+ accessToken
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return GithubAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return GithubAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
+ return null;
+ }
+ if (!tokenResponse.oauthAccessToken) {
+ return null;
+ }
+ try {
+ return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+GithubAuthProvider.GITHUB_SIGN_IN_METHOD = "github.com";
+GithubAuthProvider.PROVIDER_ID = "github.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TwitterAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("twitter.com");
+ }
+ static credential(token, secret) {
+ return OAuthCredential._fromParams({
+ providerId: TwitterAuthProvider.PROVIDER_ID,
+ signInMethod: TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,
+ oauthToken: token,
+ oauthTokenSecret: secret
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return TwitterAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return TwitterAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse) {
+ return null;
+ }
+ const { oauthAccessToken, oauthTokenSecret } = tokenResponse;
+ if (!oauthAccessToken || !oauthTokenSecret) {
+ return null;
+ }
+ try {
+ return TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+TwitterAuthProvider.TWITTER_SIGN_IN_METHOD = "twitter.com";
+TwitterAuthProvider.PROVIDER_ID = "twitter.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signUp(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signUp", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UserCredentialImpl {
+ constructor(params) {
+ this.user = params.user;
+ this.providerId = params.providerId;
+ this._tokenResponse = params._tokenResponse;
+ this.operationType = params.operationType;
+ }
+ static async _fromIdTokenResponse(auth2, operationType, idTokenResponse, isAnonymous = false) {
+ const user = await UserImpl._fromIdTokenResponse(auth2, idTokenResponse, isAnonymous);
+ const providerId = providerIdForResponse(idTokenResponse);
+ const userCred = new UserCredentialImpl({
+ user,
+ providerId,
+ _tokenResponse: idTokenResponse,
+ operationType
+ });
+ return userCred;
+ }
+ static async _forOperation(user, operationType, response) {
+ await user._updateTokensIfNecessary(response, true);
+ const providerId = providerIdForResponse(response);
+ return new UserCredentialImpl({
+ user,
+ providerId,
+ _tokenResponse: response,
+ operationType
+ });
+ }
+}
+function providerIdForResponse(response) {
+ if (response.providerId) {
+ return response.providerId;
+ }
+ if ("phoneNumber" in response) {
+ return "phone";
+ }
+ return null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class MultiFactorError extends FirebaseError {
+ constructor(auth2, error, operationType, user) {
+ var _a2;
+ super(error.code, error.message);
+ this.operationType = operationType;
+ this.user = user;
+ Object.setPrototypeOf(this, MultiFactorError.prototype);
+ this.customData = {
+ appName: auth2.name,
+ tenantId: (_a2 = auth2.tenantId) !== null && _a2 !== void 0 ? _a2 : void 0,
+ _serverResponse: error.customData._serverResponse,
+ operationType
+ };
+ }
+ static _fromErrorAndOperation(auth2, error, operationType, user) {
+ return new MultiFactorError(auth2, error, operationType, user);
+ }
+}
+function _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential, user) {
+ const idTokenProvider = operationType === "reauthenticate" ? credential._getReauthenticationResolver(auth2) : credential._getIdTokenResponse(auth2);
+ return idTokenProvider.catch((error) => {
+ if (error.code === `auth/${"multi-factor-auth-required"}`) {
+ throw MultiFactorError._fromErrorAndOperation(auth2, error, operationType, user);
+ }
+ throw error;
+ });
+}
+async function _link$1(user, credential, bypassAuthState = false) {
+ const response = await _logoutIfInvalidated(user, credential._linkToIdToken(user.auth, await user.getIdToken()), bypassAuthState);
+ return UserCredentialImpl._forOperation(user, "link", response);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _reauthenticate(user, credential, bypassAuthState = false) {
+ const { auth: auth2 } = user;
+ const operationType = "reauthenticate";
+ try {
+ const response = await _logoutIfInvalidated(user, _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential, user), bypassAuthState);
+ _assert(response.idToken, auth2, "internal-error");
+ const parsed = _parseToken(response.idToken);
+ _assert(parsed, auth2, "internal-error");
+ const { sub: localId } = parsed;
+ _assert(user.uid === localId, auth2, "user-mismatch");
+ return UserCredentialImpl._forOperation(user, operationType, response);
+ } catch (e) {
+ if ((e === null || e === void 0 ? void 0 : e.code) === `auth/${"user-not-found"}`) {
+ _fail(auth2, "user-mismatch");
+ }
+ throw e;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _signInWithCredential(auth2, credential, bypassAuthState = false) {
+ const operationType = "signIn";
+ const response = await _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential);
+ const userCredential = await UserCredentialImpl._fromIdTokenResponse(auth2, operationType, response);
+ if (!bypassAuthState) {
+ await auth2._updateCurrentUser(userCredential.user);
+ }
+ return userCredential;
+}
+async function signInWithCredential(auth2, credential) {
+ return _signInWithCredential(_castAuth(auth2), credential);
+}
+async function createUserWithEmailAndPassword(auth2, email, password) {
+ const authInternal = _castAuth(auth2);
+ const response = await signUp(authInternal, {
+ returnSecureToken: true,
+ email,
+ password
+ });
+ const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn", response);
+ await authInternal._updateCurrentUser(userCredential.user);
+ return userCredential;
+}
+function signInWithEmailAndPassword(auth2, email, password) {
+ return signInWithCredential(getModularInstance(auth2), EmailAuthProvider.credential(email, password));
+}
+function onIdTokenChanged(auth2, nextOrObserver, error, completed) {
+ return getModularInstance(auth2).onIdTokenChanged(nextOrObserver, error, completed);
+}
+function beforeAuthStateChanged(auth2, callback, onAbort) {
+ return getModularInstance(auth2).beforeAuthStateChanged(callback, onAbort);
+}
+function onAuthStateChanged(auth2, nextOrObserver, error, completed) {
+ return getModularInstance(auth2).onAuthStateChanged(nextOrObserver, error, completed);
+}
+function signOut(auth2) {
+ return getModularInstance(auth2).signOut();
+}
+const STORAGE_AVAILABLE_KEY = "__sak";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class BrowserPersistenceClass {
+ constructor(storageRetriever, type) {
+ this.storageRetriever = storageRetriever;
+ this.type = type;
+ }
+ _isAvailable() {
+ try {
+ if (!this.storage) {
+ return Promise.resolve(false);
+ }
+ this.storage.setItem(STORAGE_AVAILABLE_KEY, "1");
+ this.storage.removeItem(STORAGE_AVAILABLE_KEY);
+ return Promise.resolve(true);
+ } catch (_a2) {
+ return Promise.resolve(false);
+ }
+ }
+ _set(key, value) {
+ this.storage.setItem(key, JSON.stringify(value));
+ return Promise.resolve();
+ }
+ _get(key) {
+ const json = this.storage.getItem(key);
+ return Promise.resolve(json ? JSON.parse(json) : null);
+ }
+ _remove(key) {
+ this.storage.removeItem(key);
+ return Promise.resolve();
+ }
+ get storage() {
+ return this.storageRetriever();
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _iframeCannotSyncWebStorage() {
+ const ua2 = getUA();
+ return _isSafari(ua2) || _isIOS(ua2);
+}
+const _POLLING_INTERVAL_MS$1 = 1e3;
+const IE10_LOCAL_STORAGE_SYNC_DELAY = 10;
+class BrowserLocalPersistence extends BrowserPersistenceClass {
+ constructor() {
+ super(() => window.localStorage, "LOCAL");
+ this.boundEventHandler = (event, poll) => this.onStorageEvent(event, poll);
+ this.listeners = {};
+ this.localCache = {};
+ this.pollTimer = null;
+ this.safariLocalStorageNotSynced = _iframeCannotSyncWebStorage() && _isIframe();
+ this.fallbackToPolling = _isMobileBrowser();
+ this._shouldAllowMigration = true;
+ }
+ forAllChangedKeys(cb2) {
+ for (const key of Object.keys(this.listeners)) {
+ const newValue = this.storage.getItem(key);
+ const oldValue = this.localCache[key];
+ if (newValue !== oldValue) {
+ cb2(key, oldValue, newValue);
+ }
+ }
+ }
+ onStorageEvent(event, poll = false) {
+ if (!event.key) {
+ this.forAllChangedKeys((key2, _oldValue, newValue) => {
+ this.notifyListeners(key2, newValue);
+ });
+ return;
+ }
+ const key = event.key;
+ if (poll) {
+ this.detachListener();
+ } else {
+ this.stopPolling();
+ }
+ if (this.safariLocalStorageNotSynced) {
+ const storedValue2 = this.storage.getItem(key);
+ if (event.newValue !== storedValue2) {
+ if (event.newValue !== null) {
+ this.storage.setItem(key, event.newValue);
+ } else {
+ this.storage.removeItem(key);
+ }
+ } else if (this.localCache[key] === event.newValue && !poll) {
+ return;
+ }
+ }
+ const triggerListeners = () => {
+ const storedValue2 = this.storage.getItem(key);
+ if (!poll && this.localCache[key] === storedValue2) {
+ return;
+ }
+ this.notifyListeners(key, storedValue2);
+ };
+ const storedValue = this.storage.getItem(key);
+ if (_isIE10() && storedValue !== event.newValue && event.newValue !== event.oldValue) {
+ setTimeout(triggerListeners, IE10_LOCAL_STORAGE_SYNC_DELAY);
+ } else {
+ triggerListeners();
+ }
+ }
+ notifyListeners(key, value) {
+ this.localCache[key] = value;
+ const listeners = this.listeners[key];
+ if (listeners) {
+ for (const listener of Array.from(listeners)) {
+ listener(value ? JSON.parse(value) : value);
+ }
+ }
+ }
+ startPolling() {
+ this.stopPolling();
+ this.pollTimer = setInterval(() => {
+ this.forAllChangedKeys((key, oldValue, newValue) => {
+ this.onStorageEvent(
+ new StorageEvent("storage", {
+ key,
+ oldValue,
+ newValue
+ }),
+ true
+ );
+ });
+ }, _POLLING_INTERVAL_MS$1);
+ }
+ stopPolling() {
+ if (this.pollTimer) {
+ clearInterval(this.pollTimer);
+ this.pollTimer = null;
+ }
+ }
+ attachListener() {
+ window.addEventListener("storage", this.boundEventHandler);
+ }
+ detachListener() {
+ window.removeEventListener("storage", this.boundEventHandler);
+ }
+ _addListener(key, listener) {
+ if (Object.keys(this.listeners).length === 0) {
+ if (this.fallbackToPolling) {
+ this.startPolling();
+ } else {
+ this.attachListener();
+ }
+ }
+ if (!this.listeners[key]) {
+ this.listeners[key] = /* @__PURE__ */ new Set();
+ this.localCache[key] = this.storage.getItem(key);
+ }
+ this.listeners[key].add(listener);
+ }
+ _removeListener(key, listener) {
+ if (this.listeners[key]) {
+ this.listeners[key].delete(listener);
+ if (this.listeners[key].size === 0) {
+ delete this.listeners[key];
+ }
+ }
+ if (Object.keys(this.listeners).length === 0) {
+ this.detachListener();
+ this.stopPolling();
+ }
+ }
+ async _set(key, value) {
+ await super._set(key, value);
+ this.localCache[key] = JSON.stringify(value);
+ }
+ async _get(key) {
+ const value = await super._get(key);
+ this.localCache[key] = JSON.stringify(value);
+ return value;
+ }
+ async _remove(key) {
+ await super._remove(key);
+ delete this.localCache[key];
+ }
+}
+BrowserLocalPersistence.type = "LOCAL";
+const browserLocalPersistence = BrowserLocalPersistence;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class BrowserSessionPersistence extends BrowserPersistenceClass {
+ constructor() {
+ super(() => window.sessionStorage, "SESSION");
+ }
+ _addListener(_key, _listener) {
+ return;
+ }
+ _removeListener(_key, _listener) {
+ return;
+ }
+}
+BrowserSessionPersistence.type = "SESSION";
+const browserSessionPersistence = BrowserSessionPersistence;
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _allSettled(promises) {
+ return Promise.all(promises.map(async (promise) => {
+ try {
+ const value = await promise;
+ return {
+ fulfilled: true,
+ value
+ };
+ } catch (reason) {
+ return {
+ fulfilled: false,
+ reason
+ };
+ }
+ }));
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Receiver {
+ constructor(eventTarget) {
+ this.eventTarget = eventTarget;
+ this.handlersMap = {};
+ this.boundEventHandler = this.handleEvent.bind(this);
+ }
+ static _getInstance(eventTarget) {
+ const existingInstance = this.receivers.find((receiver) => receiver.isListeningto(eventTarget));
+ if (existingInstance) {
+ return existingInstance;
+ }
+ const newInstance = new Receiver(eventTarget);
+ this.receivers.push(newInstance);
+ return newInstance;
+ }
+ isListeningto(eventTarget) {
+ return this.eventTarget === eventTarget;
+ }
+ async handleEvent(event) {
+ const messageEvent = event;
+ const { eventId, eventType, data } = messageEvent.data;
+ const handlers = this.handlersMap[eventType];
+ if (!(handlers === null || handlers === void 0 ? void 0 : handlers.size)) {
+ return;
+ }
+ messageEvent.ports[0].postMessage({
+ status: "ack",
+ eventId,
+ eventType
+ });
+ const promises = Array.from(handlers).map(async (handler) => handler(messageEvent.origin, data));
+ const response = await _allSettled(promises);
+ messageEvent.ports[0].postMessage({
+ status: "done",
+ eventId,
+ eventType,
+ response
+ });
+ }
+ _subscribe(eventType, eventHandler) {
+ if (Object.keys(this.handlersMap).length === 0) {
+ this.eventTarget.addEventListener("message", this.boundEventHandler);
+ }
+ if (!this.handlersMap[eventType]) {
+ this.handlersMap[eventType] = /* @__PURE__ */ new Set();
+ }
+ this.handlersMap[eventType].add(eventHandler);
+ }
+ _unsubscribe(eventType, eventHandler) {
+ if (this.handlersMap[eventType] && eventHandler) {
+ this.handlersMap[eventType].delete(eventHandler);
+ }
+ if (!eventHandler || this.handlersMap[eventType].size === 0) {
+ delete this.handlersMap[eventType];
+ }
+ if (Object.keys(this.handlersMap).length === 0) {
+ this.eventTarget.removeEventListener("message", this.boundEventHandler);
+ }
+ }
+}
+Receiver.receivers = [];
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _generateEventId(prefix = "", digits = 10) {
+ let random = "";
+ for (let i = 0; i < digits; i++) {
+ random += Math.floor(Math.random() * 10);
+ }
+ return prefix + random;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Sender {
+ constructor(target) {
+ this.target = target;
+ this.handlers = /* @__PURE__ */ new Set();
+ }
+ removeMessageHandler(handler) {
+ if (handler.messageChannel) {
+ handler.messageChannel.port1.removeEventListener("message", handler.onMessage);
+ handler.messageChannel.port1.close();
+ }
+ this.handlers.delete(handler);
+ }
+ async _send(eventType, data, timeout = 50) {
+ const messageChannel = typeof MessageChannel !== "undefined" ? new MessageChannel() : null;
+ if (!messageChannel) {
+ throw new Error("connection_unavailable");
+ }
+ let completionTimer;
+ let handler;
+ return new Promise((resolve, reject) => {
+ const eventId = _generateEventId("", 20);
+ messageChannel.port1.start();
+ const ackTimer = setTimeout(() => {
+ reject(new Error("unsupported_event"));
+ }, timeout);
+ handler = {
+ messageChannel,
+ onMessage(event) {
+ const messageEvent = event;
+ if (messageEvent.data.eventId !== eventId) {
+ return;
+ }
+ switch (messageEvent.data.status) {
+ case "ack":
+ clearTimeout(ackTimer);
+ completionTimer = setTimeout(() => {
+ reject(new Error("timeout"));
+ }, 3e3);
+ break;
+ case "done":
+ clearTimeout(completionTimer);
+ resolve(messageEvent.data.response);
+ break;
+ default:
+ clearTimeout(ackTimer);
+ clearTimeout(completionTimer);
+ reject(new Error("invalid_response"));
+ break;
+ }
+ }
+ };
+ this.handlers.add(handler);
+ messageChannel.port1.addEventListener("message", handler.onMessage);
+ this.target.postMessage({
+ eventType,
+ eventId,
+ data
+ }, [messageChannel.port2]);
+ }).finally(() => {
+ if (handler) {
+ this.removeMessageHandler(handler);
+ }
+ });
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _window() {
+ return window;
+}
+function _setWindowLocation(url) {
+ _window().location.href = url;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _isWorker() {
+ return typeof _window()["WorkerGlobalScope"] !== "undefined" && typeof _window()["importScripts"] === "function";
+}
+async function _getActiveServiceWorker() {
+ if (!(navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker)) {
+ return null;
+ }
+ try {
+ const registration = await navigator.serviceWorker.ready;
+ return registration.active;
+ } catch (_a2) {
+ return null;
+ }
+}
+function _getServiceWorkerController() {
+ var _a2;
+ return ((_a2 = navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker) === null || _a2 === void 0 ? void 0 : _a2.controller) || null;
+}
+function _getWorkerGlobalScope() {
+ return _isWorker() ? self : null;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DB_NAME = "firebaseLocalStorageDb";
+const DB_VERSION = 1;
+const DB_OBJECTSTORE_NAME = "firebaseLocalStorage";
+const DB_DATA_KEYPATH = "fbase_key";
+class DBPromise {
+ constructor(request) {
+ this.request = request;
+ }
+ toPromise() {
+ return new Promise((resolve, reject) => {
+ this.request.addEventListener("success", () => {
+ resolve(this.request.result);
+ });
+ this.request.addEventListener("error", () => {
+ reject(this.request.error);
+ });
+ });
+ }
+}
+function getObjectStore(db2, isReadWrite) {
+ return db2.transaction([DB_OBJECTSTORE_NAME], isReadWrite ? "readwrite" : "readonly").objectStore(DB_OBJECTSTORE_NAME);
+}
+function _deleteDatabase() {
+ const request = indexedDB.deleteDatabase(DB_NAME);
+ return new DBPromise(request).toPromise();
+}
+function _openDatabase() {
+ const request = indexedDB.open(DB_NAME, DB_VERSION);
+ return new Promise((resolve, reject) => {
+ request.addEventListener("error", () => {
+ reject(request.error);
+ });
+ request.addEventListener("upgradeneeded", () => {
+ const db2 = request.result;
+ try {
+ db2.createObjectStore(DB_OBJECTSTORE_NAME, { keyPath: DB_DATA_KEYPATH });
+ } catch (e) {
+ reject(e);
+ }
+ });
+ request.addEventListener("success", async () => {
+ const db2 = request.result;
+ if (!db2.objectStoreNames.contains(DB_OBJECTSTORE_NAME)) {
+ db2.close();
+ await _deleteDatabase();
+ resolve(await _openDatabase());
+ } else {
+ resolve(db2);
+ }
+ });
+ });
+}
+async function _putObject(db2, key, value) {
+ const request = getObjectStore(db2, true).put({
+ [DB_DATA_KEYPATH]: key,
+ value
+ });
+ return new DBPromise(request).toPromise();
+}
+async function getObject(db2, key) {
+ const request = getObjectStore(db2, false).get(key);
+ const data = await new DBPromise(request).toPromise();
+ return data === void 0 ? null : data.value;
+}
+function _deleteObject(db2, key) {
+ const request = getObjectStore(db2, true).delete(key);
+ return new DBPromise(request).toPromise();
+}
+const _POLLING_INTERVAL_MS = 800;
+const _TRANSACTION_RETRY_COUNT = 3;
+class IndexedDBLocalPersistence {
+ constructor() {
+ this.type = "LOCAL";
+ this._shouldAllowMigration = true;
+ this.listeners = {};
+ this.localCache = {};
+ this.pollTimer = null;
+ this.pendingWrites = 0;
+ this.receiver = null;
+ this.sender = null;
+ this.serviceWorkerReceiverAvailable = false;
+ this.activeServiceWorker = null;
+ this._workerInitializationPromise = this.initializeServiceWorkerMessaging().then(() => {
+ }, () => {
+ });
+ }
+ async _openDb() {
+ if (this.db) {
+ return this.db;
+ }
+ this.db = await _openDatabase();
+ return this.db;
+ }
+ async _withRetries(op) {
+ let numAttempts = 0;
+ while (true) {
+ try {
+ const db2 = await this._openDb();
+ return await op(db2);
+ } catch (e) {
+ if (numAttempts++ > _TRANSACTION_RETRY_COUNT) {
+ throw e;
+ }
+ if (this.db) {
+ this.db.close();
+ this.db = void 0;
+ }
+ }
+ }
+ }
+ async initializeServiceWorkerMessaging() {
+ return _isWorker() ? this.initializeReceiver() : this.initializeSender();
+ }
+ async initializeReceiver() {
+ this.receiver = Receiver._getInstance(_getWorkerGlobalScope());
+ this.receiver._subscribe("keyChanged", async (_origin, data) => {
+ const keys = await this._poll();
+ return {
+ keyProcessed: keys.includes(data.key)
+ };
+ });
+ this.receiver._subscribe("ping", async (_origin, _data) => {
+ return ["keyChanged"];
+ });
+ }
+ async initializeSender() {
+ var _a2, _b;
+ this.activeServiceWorker = await _getActiveServiceWorker();
+ if (!this.activeServiceWorker) {
+ return;
+ }
+ this.sender = new Sender(this.activeServiceWorker);
+ const results = await this.sender._send("ping", {}, 800);
+ if (!results) {
+ return;
+ }
+ if (((_a2 = results[0]) === null || _a2 === void 0 ? void 0 : _a2.fulfilled) && ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.value.includes("keyChanged"))) {
+ this.serviceWorkerReceiverAvailable = true;
+ }
+ }
+ async notifyServiceWorker(key) {
+ if (!this.sender || !this.activeServiceWorker || _getServiceWorkerController() !== this.activeServiceWorker) {
+ return;
+ }
+ try {
+ await this.sender._send(
+ "keyChanged",
+ { key },
+ this.serviceWorkerReceiverAvailable ? 800 : 50
+ );
+ } catch (_a2) {
+ }
+ }
+ async _isAvailable() {
+ try {
+ if (!indexedDB) {
+ return false;
+ }
+ const db2 = await _openDatabase();
+ await _putObject(db2, STORAGE_AVAILABLE_KEY, "1");
+ await _deleteObject(db2, STORAGE_AVAILABLE_KEY);
+ return true;
+ } catch (_a2) {
+ }
+ return false;
+ }
+ async _withPendingWrite(write) {
+ this.pendingWrites++;
+ try {
+ await write();
+ } finally {
+ this.pendingWrites--;
+ }
+ }
+ async _set(key, value) {
+ return this._withPendingWrite(async () => {
+ await this._withRetries((db2) => _putObject(db2, key, value));
+ this.localCache[key] = value;
+ return this.notifyServiceWorker(key);
+ });
+ }
+ async _get(key) {
+ const obj = await this._withRetries((db2) => getObject(db2, key));
+ this.localCache[key] = obj;
+ return obj;
+ }
+ async _remove(key) {
+ return this._withPendingWrite(async () => {
+ await this._withRetries((db2) => _deleteObject(db2, key));
+ delete this.localCache[key];
+ return this.notifyServiceWorker(key);
+ });
+ }
+ async _poll() {
+ const result = await this._withRetries((db2) => {
+ const getAllRequest = getObjectStore(db2, false).getAll();
+ return new DBPromise(getAllRequest).toPromise();
+ });
+ if (!result) {
+ return [];
+ }
+ if (this.pendingWrites !== 0) {
+ return [];
+ }
+ const keys = [];
+ const keysInResult = /* @__PURE__ */ new Set();
+ for (const { fbase_key: key, value } of result) {
+ keysInResult.add(key);
+ if (JSON.stringify(this.localCache[key]) !== JSON.stringify(value)) {
+ this.notifyListeners(key, value);
+ keys.push(key);
+ }
+ }
+ for (const localKey of Object.keys(this.localCache)) {
+ if (this.localCache[localKey] && !keysInResult.has(localKey)) {
+ this.notifyListeners(localKey, null);
+ keys.push(localKey);
+ }
+ }
+ return keys;
+ }
+ notifyListeners(key, newValue) {
+ this.localCache[key] = newValue;
+ const listeners = this.listeners[key];
+ if (listeners) {
+ for (const listener of Array.from(listeners)) {
+ listener(newValue);
+ }
+ }
+ }
+ startPolling() {
+ this.stopPolling();
+ this.pollTimer = setInterval(async () => this._poll(), _POLLING_INTERVAL_MS);
+ }
+ stopPolling() {
+ if (this.pollTimer) {
+ clearInterval(this.pollTimer);
+ this.pollTimer = null;
+ }
+ }
+ _addListener(key, listener) {
+ if (Object.keys(this.listeners).length === 0) {
+ this.startPolling();
+ }
+ if (!this.listeners[key]) {
+ this.listeners[key] = /* @__PURE__ */ new Set();
+ void this._get(key);
+ }
+ this.listeners[key].add(listener);
+ }
+ _removeListener(key, listener) {
+ if (this.listeners[key]) {
+ this.listeners[key].delete(listener);
+ if (this.listeners[key].size === 0) {
+ delete this.listeners[key];
+ }
+ }
+ if (Object.keys(this.listeners).length === 0) {
+ this.stopPolling();
+ }
+ }
+}
+IndexedDBLocalPersistence.type = "LOCAL";
+const indexedDBLocalPersistence = IndexedDBLocalPersistence;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getScriptParentElement() {
+ var _a2, _b;
+ return (_b = (_a2 = document.getElementsByTagName("head")) === null || _a2 === void 0 ? void 0 : _a2[0]) !== null && _b !== void 0 ? _b : document;
+}
+function _loadJS(url) {
+ return new Promise((resolve, reject) => {
+ const el2 = document.createElement("script");
+ el2.setAttribute("src", url);
+ el2.onload = resolve;
+ el2.onerror = (e) => {
+ const error = _createError("internal-error");
+ error.customData = e;
+ reject(error);
+ };
+ el2.type = "text/javascript";
+ el2.charset = "UTF-8";
+ getScriptParentElement().appendChild(el2);
+ });
+}
+function _generateCallbackName(prefix) {
+ return `__${prefix}${Math.floor(Math.random() * 1e6)}`;
+}
+new Delay(3e4, 6e4);
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _withDefaultResolver(auth2, resolverOverride) {
+ if (resolverOverride) {
+ return _getInstance(resolverOverride);
+ }
+ _assert(auth2._popupRedirectResolver, auth2, "argument-error");
+ return auth2._popupRedirectResolver;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class IdpCredential extends AuthCredential {
+ constructor(params) {
+ super("custom", "custom");
+ this.params = params;
+ }
+ _getIdTokenResponse(auth2) {
+ return signInWithIdp(auth2, this._buildIdpRequest());
+ }
+ _linkToIdToken(auth2, idToken) {
+ return signInWithIdp(auth2, this._buildIdpRequest(idToken));
+ }
+ _getReauthenticationResolver(auth2) {
+ return signInWithIdp(auth2, this._buildIdpRequest());
+ }
+ _buildIdpRequest(idToken) {
+ const request = {
+ requestUri: this.params.requestUri,
+ sessionId: this.params.sessionId,
+ postBody: this.params.postBody,
+ tenantId: this.params.tenantId,
+ pendingToken: this.params.pendingToken,
+ returnSecureToken: true,
+ returnIdpCredential: true
+ };
+ if (idToken) {
+ request.idToken = idToken;
+ }
+ return request;
+ }
+}
+function _signIn(params) {
+ return _signInWithCredential(params.auth, new IdpCredential(params), params.bypassAuthState);
+}
+function _reauth(params) {
+ const { auth: auth2, user } = params;
+ _assert(user, auth2, "internal-error");
+ return _reauthenticate(user, new IdpCredential(params), params.bypassAuthState);
+}
+async function _link(params) {
+ const { auth: auth2, user } = params;
+ _assert(user, auth2, "internal-error");
+ return _link$1(user, new IdpCredential(params), params.bypassAuthState);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AbstractPopupRedirectOperation {
+ constructor(auth2, filter, resolver, user, bypassAuthState = false) {
+ this.auth = auth2;
+ this.resolver = resolver;
+ this.user = user;
+ this.bypassAuthState = bypassAuthState;
+ this.pendingPromise = null;
+ this.eventManager = null;
+ this.filter = Array.isArray(filter) ? filter : [filter];
+ }
+ execute() {
+ return new Promise(async (resolve, reject) => {
+ this.pendingPromise = { resolve, reject };
+ try {
+ this.eventManager = await this.resolver._initialize(this.auth);
+ await this.onExecution();
+ this.eventManager.registerConsumer(this);
+ } catch (e) {
+ this.reject(e);
+ }
+ });
+ }
+ async onAuthEvent(event) {
+ const { urlResponse, sessionId, postBody, tenantId, error, type } = event;
+ if (error) {
+ this.reject(error);
+ return;
+ }
+ const params = {
+ auth: this.auth,
+ requestUri: urlResponse,
+ sessionId,
+ tenantId: tenantId || void 0,
+ postBody: postBody || void 0,
+ user: this.user,
+ bypassAuthState: this.bypassAuthState
+ };
+ try {
+ this.resolve(await this.getIdpTask(type)(params));
+ } catch (e) {
+ this.reject(e);
+ }
+ }
+ onError(error) {
+ this.reject(error);
+ }
+ getIdpTask(type) {
+ switch (type) {
+ case "signInViaPopup":
+ case "signInViaRedirect":
+ return _signIn;
+ case "linkViaPopup":
+ case "linkViaRedirect":
+ return _link;
+ case "reauthViaPopup":
+ case "reauthViaRedirect":
+ return _reauth;
+ default:
+ _fail(this.auth, "internal-error");
+ }
+ }
+ resolve(cred) {
+ debugAssert(this.pendingPromise, "Pending promise was never set");
+ this.pendingPromise.resolve(cred);
+ this.unregisterAndCleanUp();
+ }
+ reject(error) {
+ debugAssert(this.pendingPromise, "Pending promise was never set");
+ this.pendingPromise.reject(error);
+ this.unregisterAndCleanUp();
+ }
+ unregisterAndCleanUp() {
+ if (this.eventManager) {
+ this.eventManager.unregisterConsumer(this);
+ }
+ this.pendingPromise = null;
+ this.cleanUp();
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const _POLL_WINDOW_CLOSE_TIMEOUT = new Delay(2e3, 1e4);
+async function signInWithPopup(auth2, provider2, resolver) {
+ const authInternal = _castAuth(auth2);
+ _assertInstanceOf(auth2, provider2, FederatedAuthProvider);
+ const resolverInternal = _withDefaultResolver(authInternal, resolver);
+ const action = new PopupOperation(authInternal, "signInViaPopup", provider2, resolverInternal);
+ return action.executeNotNull();
+}
+class PopupOperation extends AbstractPopupRedirectOperation {
+ constructor(auth2, filter, provider2, resolver, user) {
+ super(auth2, filter, resolver, user);
+ this.provider = provider2;
+ this.authWindow = null;
+ this.pollId = null;
+ if (PopupOperation.currentPopupAction) {
+ PopupOperation.currentPopupAction.cancel();
+ }
+ PopupOperation.currentPopupAction = this;
+ }
+ async executeNotNull() {
+ const result = await this.execute();
+ _assert(result, this.auth, "internal-error");
+ return result;
+ }
+ async onExecution() {
+ debugAssert(this.filter.length === 1, "Popup operations only handle one event");
+ const eventId = _generateEventId();
+ this.authWindow = await this.resolver._openPopup(
+ this.auth,
+ this.provider,
+ this.filter[0],
+ eventId
+ );
+ this.authWindow.associatedEvent = eventId;
+ this.resolver._originValidation(this.auth).catch((e) => {
+ this.reject(e);
+ });
+ this.resolver._isIframeWebStorageSupported(this.auth, (isSupported) => {
+ if (!isSupported) {
+ this.reject(_createError(this.auth, "web-storage-unsupported"));
+ }
+ });
+ this.pollUserCancellation();
+ }
+ get eventId() {
+ var _a2;
+ return ((_a2 = this.authWindow) === null || _a2 === void 0 ? void 0 : _a2.associatedEvent) || null;
+ }
+ cancel() {
+ this.reject(_createError(this.auth, "cancelled-popup-request"));
+ }
+ cleanUp() {
+ if (this.authWindow) {
+ this.authWindow.close();
+ }
+ if (this.pollId) {
+ window.clearTimeout(this.pollId);
+ }
+ this.authWindow = null;
+ this.pollId = null;
+ PopupOperation.currentPopupAction = null;
+ }
+ pollUserCancellation() {
+ const poll = () => {
+ var _a2, _b;
+ if ((_b = (_a2 = this.authWindow) === null || _a2 === void 0 ? void 0 : _a2.window) === null || _b === void 0 ? void 0 : _b.closed) {
+ this.pollId = window.setTimeout(() => {
+ this.pollId = null;
+ this.reject(_createError(this.auth, "popup-closed-by-user"));
+ }, 2e3);
+ return;
+ }
+ this.pollId = window.setTimeout(poll, _POLL_WINDOW_CLOSE_TIMEOUT.get());
+ };
+ poll();
+ }
+}
+PopupOperation.currentPopupAction = null;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const PENDING_REDIRECT_KEY = "pendingRedirect";
+const redirectOutcomeMap = /* @__PURE__ */ new Map();
+class RedirectAction extends AbstractPopupRedirectOperation {
+ constructor(auth2, resolver, bypassAuthState = false) {
+ super(auth2, [
+ "signInViaRedirect",
+ "linkViaRedirect",
+ "reauthViaRedirect",
+ "unknown"
+ ], resolver, void 0, bypassAuthState);
+ this.eventId = null;
+ }
+ async execute() {
+ let readyOutcome = redirectOutcomeMap.get(this.auth._key());
+ if (!readyOutcome) {
+ try {
+ const hasPendingRedirect = await _getAndClearPendingRedirectStatus(this.resolver, this.auth);
+ const result = hasPendingRedirect ? await super.execute() : null;
+ readyOutcome = () => Promise.resolve(result);
+ } catch (e) {
+ readyOutcome = () => Promise.reject(e);
+ }
+ redirectOutcomeMap.set(this.auth._key(), readyOutcome);
+ }
+ if (!this.bypassAuthState) {
+ redirectOutcomeMap.set(this.auth._key(), () => Promise.resolve(null));
+ }
+ return readyOutcome();
+ }
+ async onAuthEvent(event) {
+ if (event.type === "signInViaRedirect") {
+ return super.onAuthEvent(event);
+ } else if (event.type === "unknown") {
+ this.resolve(null);
+ return;
+ }
+ if (event.eventId) {
+ const user = await this.auth._redirectUserForId(event.eventId);
+ if (user) {
+ this.user = user;
+ return super.onAuthEvent(event);
+ } else {
+ this.resolve(null);
+ }
+ }
+ }
+ async onExecution() {
+ }
+ cleanUp() {
+ }
+}
+async function _getAndClearPendingRedirectStatus(resolver, auth2) {
+ const key = pendingRedirectKey(auth2);
+ const persistence = resolverPersistence(resolver);
+ if (!await persistence._isAvailable()) {
+ return false;
+ }
+ const hasPendingRedirect = await persistence._get(key) === "true";
+ await persistence._remove(key);
+ return hasPendingRedirect;
+}
+function _overrideRedirectResult(auth2, result) {
+ redirectOutcomeMap.set(auth2._key(), result);
+}
+function resolverPersistence(resolver) {
+ return _getInstance(resolver._redirectPersistence);
+}
+function pendingRedirectKey(auth2) {
+ return _persistenceKeyName(PENDING_REDIRECT_KEY, auth2.config.apiKey, auth2.name);
+}
+async function _getRedirectResult(auth2, resolverExtern, bypassAuthState = false) {
+ const authInternal = _castAuth(auth2);
+ const resolver = _withDefaultResolver(authInternal, resolverExtern);
+ const action = new RedirectAction(authInternal, resolver, bypassAuthState);
+ const result = await action.execute();
+ if (result && !bypassAuthState) {
+ delete result.user._redirectEventId;
+ await authInternal._persistUserIfCurrent(result.user);
+ await authInternal._setRedirectUser(null, resolverExtern);
+ }
+ return result;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1e3;
+class AuthEventManager {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.cachedEventUids = /* @__PURE__ */ new Set();
+ this.consumers = /* @__PURE__ */ new Set();
+ this.queuedRedirectEvent = null;
+ this.hasHandledPotentialRedirect = false;
+ this.lastProcessedEventTime = Date.now();
+ }
+ registerConsumer(authEventConsumer) {
+ this.consumers.add(authEventConsumer);
+ if (this.queuedRedirectEvent && this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)) {
+ this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer);
+ this.saveEventToCache(this.queuedRedirectEvent);
+ this.queuedRedirectEvent = null;
+ }
+ }
+ unregisterConsumer(authEventConsumer) {
+ this.consumers.delete(authEventConsumer);
+ }
+ onEvent(event) {
+ if (this.hasEventBeenHandled(event)) {
+ return false;
+ }
+ let handled = false;
+ this.consumers.forEach((consumer) => {
+ if (this.isEventForConsumer(event, consumer)) {
+ handled = true;
+ this.sendToConsumer(event, consumer);
+ this.saveEventToCache(event);
+ }
+ });
+ if (this.hasHandledPotentialRedirect || !isRedirectEvent(event)) {
+ return handled;
+ }
+ this.hasHandledPotentialRedirect = true;
+ if (!handled) {
+ this.queuedRedirectEvent = event;
+ handled = true;
+ }
+ return handled;
+ }
+ sendToConsumer(event, consumer) {
+ var _a2;
+ if (event.error && !isNullRedirectEvent(event)) {
+ const code = ((_a2 = event.error.code) === null || _a2 === void 0 ? void 0 : _a2.split("auth/")[1]) || "internal-error";
+ consumer.onError(_createError(this.auth, code));
+ } else {
+ consumer.onAuthEvent(event);
+ }
+ }
+ isEventForConsumer(event, consumer) {
+ const eventIdMatches = consumer.eventId === null || !!event.eventId && event.eventId === consumer.eventId;
+ return consumer.filter.includes(event.type) && eventIdMatches;
+ }
+ hasEventBeenHandled(event) {
+ if (Date.now() - this.lastProcessedEventTime >= EVENT_DUPLICATION_CACHE_DURATION_MS) {
+ this.cachedEventUids.clear();
+ }
+ return this.cachedEventUids.has(eventUid(event));
+ }
+ saveEventToCache(event) {
+ this.cachedEventUids.add(eventUid(event));
+ this.lastProcessedEventTime = Date.now();
+ }
+}
+function eventUid(e) {
+ return [e.type, e.eventId, e.sessionId, e.tenantId].filter((v2) => v2).join("-");
+}
+function isNullRedirectEvent({ type, error }) {
+ return type === "unknown" && (error === null || error === void 0 ? void 0 : error.code) === `auth/${"no-auth-event"}`;
+}
+function isRedirectEvent(event) {
+ switch (event.type) {
+ case "signInViaRedirect":
+ case "linkViaRedirect":
+ case "reauthViaRedirect":
+ return true;
+ case "unknown":
+ return isNullRedirectEvent(event);
+ default:
+ return false;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _getProjectConfig(auth2, request = {}) {
+ return _performApiRequest(auth2, "GET", "/v1/projects", request);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const IP_ADDRESS_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const HTTP_REGEX = /^https?/;
+async function _validateOrigin(auth2) {
+ if (auth2.config.emulator) {
+ return;
+ }
+ const { authorizedDomains } = await _getProjectConfig(auth2);
+ for (const domain of authorizedDomains) {
+ try {
+ if (matchDomain(domain)) {
+ return;
+ }
+ } catch (_a2) {
+ }
+ }
+ _fail(auth2, "unauthorized-domain");
+}
+function matchDomain(expected) {
+ const currentUrl = _getCurrentUrl();
+ const { protocol, hostname } = new URL(currentUrl);
+ if (expected.startsWith("chrome-extension://")) {
+ const ceUrl = new URL(expected);
+ if (ceUrl.hostname === "" && hostname === "") {
+ return protocol === "chrome-extension:" && expected.replace("chrome-extension://", "") === currentUrl.replace("chrome-extension://", "");
+ }
+ return protocol === "chrome-extension:" && ceUrl.hostname === hostname;
+ }
+ if (!HTTP_REGEX.test(protocol)) {
+ return false;
+ }
+ if (IP_ADDRESS_REGEX.test(expected)) {
+ return hostname === expected;
+ }
+ const escapedDomainPattern = expected.replace(/\./g, "\\.");
+ const re = new RegExp("^(.+\\." + escapedDomainPattern + "|" + escapedDomainPattern + ")$", "i");
+ return re.test(hostname);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const NETWORK_TIMEOUT = new Delay(3e4, 6e4);
+function resetUnloadedGapiModules() {
+ const beacon = _window().___jsl;
+ if (beacon === null || beacon === void 0 ? void 0 : beacon.H) {
+ for (const hint of Object.keys(beacon.H)) {
+ beacon.H[hint].r = beacon.H[hint].r || [];
+ beacon.H[hint].L = beacon.H[hint].L || [];
+ beacon.H[hint].r = [...beacon.H[hint].L];
+ if (beacon.CP) {
+ for (let i = 0; i < beacon.CP.length; i++) {
+ beacon.CP[i] = null;
+ }
+ }
+ }
+ }
+}
+function loadGapi(auth2) {
+ return new Promise((resolve, reject) => {
+ var _a2, _b, _c2;
+ function loadGapiIframe() {
+ resetUnloadedGapiModules();
+ gapi.load("gapi.iframes", {
+ callback: () => {
+ resolve(gapi.iframes.getContext());
+ },
+ ontimeout: () => {
+ resetUnloadedGapiModules();
+ reject(_createError(auth2, "network-request-failed"));
+ },
+ timeout: NETWORK_TIMEOUT.get()
+ });
+ }
+ if ((_b = (_a2 = _window().gapi) === null || _a2 === void 0 ? void 0 : _a2.iframes) === null || _b === void 0 ? void 0 : _b.Iframe) {
+ resolve(gapi.iframes.getContext());
+ } else if (!!((_c2 = _window().gapi) === null || _c2 === void 0 ? void 0 : _c2.load)) {
+ loadGapiIframe();
+ } else {
+ const cbName = _generateCallbackName("iframefcb");
+ _window()[cbName] = () => {
+ if (!!gapi.load) {
+ loadGapiIframe();
+ } else {
+ reject(_createError(auth2, "network-request-failed"));
+ }
+ };
+ return _loadJS(`https://apis.google.com/js/api.js?onload=${cbName}`).catch((e) => reject(e));
+ }
+ }).catch((error) => {
+ cachedGApiLoader = null;
+ throw error;
+ });
+}
+let cachedGApiLoader = null;
+function _loadGapi(auth2) {
+ cachedGApiLoader = cachedGApiLoader || loadGapi(auth2);
+ return cachedGApiLoader;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const PING_TIMEOUT = new Delay(5e3, 15e3);
+const IFRAME_PATH = "__/auth/iframe";
+const EMULATED_IFRAME_PATH = "emulator/auth/iframe";
+const IFRAME_ATTRIBUTES = {
+ style: {
+ position: "absolute",
+ top: "-100px",
+ width: "1px",
+ height: "1px"
+ },
+ "aria-hidden": "true",
+ tabindex: "-1"
+};
+const EID_FROM_APIHOST = /* @__PURE__ */ new Map([
+ ["identitytoolkit.googleapis.com", "p"],
+ ["staging-identitytoolkit.sandbox.googleapis.com", "s"],
+ ["test-identitytoolkit.sandbox.googleapis.com", "t"]
+]);
+function getIframeUrl(auth2) {
+ const config = auth2.config;
+ _assert(config.authDomain, auth2, "auth-domain-config-required");
+ const url = config.emulator ? _emulatorUrl(config, EMULATED_IFRAME_PATH) : `https://${auth2.config.authDomain}/${IFRAME_PATH}`;
+ const params = {
+ apiKey: config.apiKey,
+ appName: auth2.name,
+ v: SDK_VERSION
+ };
+ const eid = EID_FROM_APIHOST.get(auth2.config.apiHost);
+ if (eid) {
+ params.eid = eid;
+ }
+ const frameworks = auth2._getFrameworks();
+ if (frameworks.length) {
+ params.fw = frameworks.join(",");
+ }
+ return `${url}?${querystring(params).slice(1)}`;
+}
+async function _openIframe(auth2) {
+ const context = await _loadGapi(auth2);
+ const gapi2 = _window().gapi;
+ _assert(gapi2, auth2, "internal-error");
+ return context.open({
+ where: document.body,
+ url: getIframeUrl(auth2),
+ messageHandlersFilter: gapi2.iframes.CROSS_ORIGIN_IFRAMES_FILTER,
+ attributes: IFRAME_ATTRIBUTES,
+ dontclear: true
+ }, (iframe) => new Promise(async (resolve, reject) => {
+ await iframe.restyle({
+ setHideOnLeave: false
+ });
+ const networkError = _createError(auth2, "network-request-failed");
+ const networkErrorTimer = _window().setTimeout(() => {
+ reject(networkError);
+ }, PING_TIMEOUT.get());
+ function clearTimerAndResolve() {
+ _window().clearTimeout(networkErrorTimer);
+ resolve(iframe);
+ }
+ iframe.ping(clearTimerAndResolve).then(clearTimerAndResolve, () => {
+ reject(networkError);
+ });
+ }));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const BASE_POPUP_OPTIONS = {
+ location: "yes",
+ resizable: "yes",
+ statusbar: "yes",
+ toolbar: "no"
+};
+const DEFAULT_WIDTH = 500;
+const DEFAULT_HEIGHT = 600;
+const TARGET_BLANK = "_blank";
+const FIREFOX_EMPTY_URL = "http://localhost";
+class AuthPopup {
+ constructor(window2) {
+ this.window = window2;
+ this.associatedEvent = null;
+ }
+ close() {
+ if (this.window) {
+ try {
+ this.window.close();
+ } catch (e) {
+ }
+ }
+ }
+}
+function _open(auth2, url, name2, width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT) {
+ const top = Math.max((window.screen.availHeight - height) / 2, 0).toString();
+ const left = Math.max((window.screen.availWidth - width) / 2, 0).toString();
+ let target = "";
+ const options = Object.assign(Object.assign({}, BASE_POPUP_OPTIONS), {
+ width: width.toString(),
+ height: height.toString(),
+ top,
+ left
+ });
+ const ua2 = getUA().toLowerCase();
+ if (name2) {
+ target = _isChromeIOS(ua2) ? TARGET_BLANK : name2;
+ }
+ if (_isFirefox(ua2)) {
+ url = url || FIREFOX_EMPTY_URL;
+ options.scrollbars = "yes";
+ }
+ const optionsString = Object.entries(options).reduce((accum, [key, value]) => `${accum}${key}=${value},`, "");
+ if (_isIOSStandalone(ua2) && target !== "_self") {
+ openAsNewWindowIOS(url || "", target);
+ return new AuthPopup(null);
+ }
+ const newWin = window.open(url || "", target, optionsString);
+ _assert(newWin, auth2, "popup-blocked");
+ try {
+ newWin.focus();
+ } catch (e) {
+ }
+ return new AuthPopup(newWin);
+}
+function openAsNewWindowIOS(url, target) {
+ const el2 = document.createElement("a");
+ el2.href = url;
+ el2.target = target;
+ const click = document.createEvent("MouseEvent");
+ click.initMouseEvent("click", true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 1, null);
+ el2.dispatchEvent(click);
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const WIDGET_PATH = "__/auth/handler";
+const EMULATOR_WIDGET_PATH = "emulator/auth/handler";
+function _getRedirectUrl(auth2, provider2, authType, redirectUrl, eventId, additionalParams) {
+ _assert(auth2.config.authDomain, auth2, "auth-domain-config-required");
+ _assert(auth2.config.apiKey, auth2, "invalid-api-key");
+ const params = {
+ apiKey: auth2.config.apiKey,
+ appName: auth2.name,
+ authType,
+ redirectUrl,
+ v: SDK_VERSION,
+ eventId
+ };
+ if (provider2 instanceof FederatedAuthProvider) {
+ provider2.setDefaultLanguage(auth2.languageCode);
+ params.providerId = provider2.providerId || "";
+ if (!isEmpty(provider2.getCustomParameters())) {
+ params.customParameters = JSON.stringify(provider2.getCustomParameters());
+ }
+ for (const [key, value] of Object.entries(additionalParams || {})) {
+ params[key] = value;
+ }
+ }
+ if (provider2 instanceof BaseOAuthProvider) {
+ const scopes = provider2.getScopes().filter((scope) => scope !== "");
+ if (scopes.length > 0) {
+ params.scopes = scopes.join(",");
+ }
+ }
+ if (auth2.tenantId) {
+ params.tid = auth2.tenantId;
+ }
+ const paramsDict = params;
+ for (const key of Object.keys(paramsDict)) {
+ if (paramsDict[key] === void 0) {
+ delete paramsDict[key];
+ }
+ }
+ return `${getHandlerBase(auth2)}?${querystring(paramsDict).slice(1)}`;
+}
+function getHandlerBase({ config }) {
+ if (!config.emulator) {
+ return `https://${config.authDomain}/${WIDGET_PATH}`;
+ }
+ return _emulatorUrl(config, EMULATOR_WIDGET_PATH);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const WEB_STORAGE_SUPPORT_KEY = "webStorageSupport";
+class BrowserPopupRedirectResolver {
+ constructor() {
+ this.eventManagers = {};
+ this.iframes = {};
+ this.originValidationPromises = {};
+ this._redirectPersistence = browserSessionPersistence;
+ this._completeRedirectFn = _getRedirectResult;
+ this._overrideRedirectResult = _overrideRedirectResult;
+ }
+ async _openPopup(auth2, provider2, authType, eventId) {
+ var _a2;
+ debugAssert((_a2 = this.eventManagers[auth2._key()]) === null || _a2 === void 0 ? void 0 : _a2.manager, "_initialize() not called before _openPopup()");
+ const url = _getRedirectUrl(auth2, provider2, authType, _getCurrentUrl(), eventId);
+ return _open(auth2, url, _generateEventId());
+ }
+ async _openRedirect(auth2, provider2, authType, eventId) {
+ await this._originValidation(auth2);
+ _setWindowLocation(_getRedirectUrl(auth2, provider2, authType, _getCurrentUrl(), eventId));
+ return new Promise(() => {
+ });
+ }
+ _initialize(auth2) {
+ const key = auth2._key();
+ if (this.eventManagers[key]) {
+ const { manager, promise: promise2 } = this.eventManagers[key];
+ if (manager) {
+ return Promise.resolve(manager);
+ } else {
+ debugAssert(promise2, "If manager is not set, promise should be");
+ return promise2;
+ }
+ }
+ const promise = this.initAndGetManager(auth2);
+ this.eventManagers[key] = { promise };
+ promise.catch(() => {
+ delete this.eventManagers[key];
+ });
+ return promise;
+ }
+ async initAndGetManager(auth2) {
+ const iframe = await _openIframe(auth2);
+ const manager = new AuthEventManager(auth2);
+ iframe.register("authEvent", (iframeEvent) => {
+ _assert(iframeEvent === null || iframeEvent === void 0 ? void 0 : iframeEvent.authEvent, auth2, "invalid-auth-event");
+ const handled = manager.onEvent(iframeEvent.authEvent);
+ return { status: handled ? "ACK" : "ERROR" };
+ }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+ this.eventManagers[auth2._key()] = { manager };
+ this.iframes[auth2._key()] = iframe;
+ return manager;
+ }
+ _isIframeWebStorageSupported(auth2, cb2) {
+ const iframe = this.iframes[auth2._key()];
+ iframe.send(WEB_STORAGE_SUPPORT_KEY, { type: WEB_STORAGE_SUPPORT_KEY }, (result) => {
+ var _a2;
+ const isSupported = (_a2 = result === null || result === void 0 ? void 0 : result[0]) === null || _a2 === void 0 ? void 0 : _a2[WEB_STORAGE_SUPPORT_KEY];
+ if (isSupported !== void 0) {
+ cb2(!!isSupported);
+ }
+ _fail(auth2, "internal-error");
+ }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+ }
+ _originValidation(auth2) {
+ const key = auth2._key();
+ if (!this.originValidationPromises[key]) {
+ this.originValidationPromises[key] = _validateOrigin(auth2);
+ }
+ return this.originValidationPromises[key];
+ }
+ get _shouldInitProactively() {
+ return _isMobileBrowser() || _isSafari() || _isIOS();
+ }
+}
+const browserPopupRedirectResolver = BrowserPopupRedirectResolver;
+var name$1 = "@firebase/auth";
+var version$1 = "0.22.0";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthInterop {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.internalListeners = /* @__PURE__ */ new Map();
+ }
+ getUid() {
+ var _a2;
+ this.assertAuthConfigured();
+ return ((_a2 = this.auth.currentUser) === null || _a2 === void 0 ? void 0 : _a2.uid) || null;
+ }
+ async getToken(forceRefresh) {
+ this.assertAuthConfigured();
+ await this.auth._initializationPromise;
+ if (!this.auth.currentUser) {
+ return null;
+ }
+ const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);
+ return { accessToken };
+ }
+ addAuthTokenListener(listener) {
+ this.assertAuthConfigured();
+ if (this.internalListeners.has(listener)) {
+ return;
+ }
+ const unsubscribe = this.auth.onIdTokenChanged((user) => {
+ listener((user === null || user === void 0 ? void 0 : user.stsTokenManager.accessToken) || null);
+ });
+ this.internalListeners.set(listener, unsubscribe);
+ this.updateProactiveRefresh();
+ }
+ removeAuthTokenListener(listener) {
+ this.assertAuthConfigured();
+ const unsubscribe = this.internalListeners.get(listener);
+ if (!unsubscribe) {
+ return;
+ }
+ this.internalListeners.delete(listener);
+ unsubscribe();
+ this.updateProactiveRefresh();
+ }
+ assertAuthConfigured() {
+ _assert(this.auth._initializationPromise, "dependent-sdk-initialized-before-auth");
+ }
+ updateProactiveRefresh() {
+ if (this.internalListeners.size > 0) {
+ this.auth._startProactiveRefresh();
+ } else {
+ this.auth._stopProactiveRefresh();
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getVersionForPlatform(clientPlatform) {
+ switch (clientPlatform) {
+ case "Node":
+ return "node";
+ case "ReactNative":
+ return "rn";
+ case "Worker":
+ return "webworker";
+ case "Cordova":
+ return "cordova";
+ default:
+ return void 0;
+ }
+}
+function registerAuth(clientPlatform) {
+ _registerComponent(new Component("auth", (container, { options: deps }) => {
+ const app2 = container.getProvider("app").getImmediate();
+ const heartbeatServiceProvider = container.getProvider("heartbeat");
+ const { apiKey, authDomain } = app2.options;
+ return ((app3, heartbeatServiceProvider2) => {
+ _assert(apiKey && !apiKey.includes(":"), "invalid-api-key", { appName: app3.name });
+ _assert(!(authDomain === null || authDomain === void 0 ? void 0 : authDomain.includes(":")), "argument-error", {
+ appName: app3.name
+ });
+ const config = {
+ apiKey,
+ authDomain,
+ clientPlatform,
+ apiHost: "identitytoolkit.googleapis.com",
+ tokenApiHost: "securetoken.googleapis.com",
+ apiScheme: "https",
+ sdkClientVersion: _getClientVersion(clientPlatform)
+ };
+ const authInstance = new AuthImpl(app3, heartbeatServiceProvider2, config);
+ _initializeAuthInstance(authInstance, deps);
+ return authInstance;
+ })(app2, heartbeatServiceProvider);
+ }, "PUBLIC").setInstantiationMode("EXPLICIT").setInstanceCreatedCallback((container, _instanceIdentifier, _instance) => {
+ const authInternalProvider = container.getProvider("auth-internal");
+ authInternalProvider.initialize();
+ }));
+ _registerComponent(new Component("auth-internal", (container) => {
+ const auth2 = _castAuth(container.getProvider("auth").getImmediate());
+ return ((auth3) => new AuthInterop(auth3))(auth2);
+ }, "PRIVATE").setInstantiationMode("EXPLICIT"));
+ registerVersion(name$1, version$1, getVersionForPlatform(clientPlatform));
+ registerVersion(name$1, version$1, "esm2017");
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_ID_TOKEN_MAX_AGE = 5 * 60;
+const authIdTokenMaxAge = getExperimentalSetting("authIdTokenMaxAge") || DEFAULT_ID_TOKEN_MAX_AGE;
+let lastPostedIdToken = null;
+const mintCookieFactory = (url) => async (user) => {
+ const idTokenResult = user && await user.getIdTokenResult();
+ const idTokenAge = idTokenResult && (new Date().getTime() - Date.parse(idTokenResult.issuedAtTime)) / 1e3;
+ if (idTokenAge && idTokenAge > authIdTokenMaxAge) {
+ return;
+ }
+ const idToken = idTokenResult === null || idTokenResult === void 0 ? void 0 : idTokenResult.token;
+ if (lastPostedIdToken === idToken) {
+ return;
+ }
+ lastPostedIdToken = idToken;
+ await fetch(url, {
+ method: idToken ? "POST" : "DELETE",
+ headers: idToken ? {
+ "Authorization": `Bearer ${idToken}`
+ } : {}
+ });
+};
+function getAuth(app2 = getApp()) {
+ const provider2 = _getProvider(app2, "auth");
+ if (provider2.isInitialized()) {
+ return provider2.getImmediate();
+ }
+ const auth2 = initializeAuth(app2, {
+ popupRedirectResolver: browserPopupRedirectResolver,
+ persistence: [
+ indexedDBLocalPersistence,
+ browserLocalPersistence,
+ browserSessionPersistence
+ ]
+ });
+ const authTokenSyncUrl = getExperimentalSetting("authTokenSyncURL");
+ if (authTokenSyncUrl) {
+ const mintCookie = mintCookieFactory(authTokenSyncUrl);
+ beforeAuthStateChanged(auth2, mintCookie, () => mintCookie(auth2.currentUser));
+ onIdTokenChanged(auth2, (user) => mintCookie(user));
+ }
+ const authEmulatorHost = getDefaultEmulatorHost("auth");
+ if (authEmulatorHost) {
+ connectAuthEmulator(auth2, `http://${authEmulatorHost}`);
+ }
+ return auth2;
+}
+registerAuth("Browser");
+function mistake(navigateTo2) {
+ const bug = document.createElement("div");
+ bug.innerHTML = ` Error 404: p\xE1gina no encontrada.
+ volver al Inicio
+ Salir `;
+ const salir = postForm.querySelector(".goOut");
+ salir.addEventListener("click", () => {
+ signOut(auth).then(() => {
+ navigateTo2("/");
+ }).catch(() => {
+ });
+ });
+ const buttonPost = postForm.querySelector(".post");
+ buttonPost.addEventListener("click", (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector(".areaPost");
+ const postText = textarea.value;
+ if (postText.trim() !== "") {
+ post(postText);
+ } else {
+ alert("Ingrese post");
+ }
+ textarea.value = "";
+ });
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement("div");
+ postContainer.classList.add("divPost");
+ const name2 = document.createElement("h6");
+ name2.classList.add("userName");
+ postContainer.appendChild(name2);
+ name2.innerHTML = `${info.userEmail}`;
+ const textarea = document.createElement("textarea");
+ textarea.classList.add("showPost");
+ textarea.value = info.text;
+ postContainer.setAttribute("data-id", doc.id);
+ textarea.setAttribute("readonly", true);
+ postContainer.appendChild(textarea);
+ const buttonsContainer = document.createElement("div");
+ buttonsContainer.classList.add("buttonsPost");
+ const editButton = document.createElement("button");
+ editButton.classList.add("edit");
+ editButton.textContent = "Editar";
+ editButton.addEventListener("click", () => {
+ if (editButton.textContent === "Editar") {
+ editButton.textContent = "Guardar";
+ textarea.removeAttribute("readonly");
+ } else if (editButton.textContent === "Guardar") {
+ const editedTextarea = postContainer.querySelector("textarea").value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = "Editar";
+ textarea.setAttribute("readonly", true);
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+ const deleteButton = document.createElement("button");
+ deleteButton.classList.add("delete-btn");
+ deleteButton.textContent = "Eliminar";
+ deleteButton.addEventListener("click", () => {
+ const confirmDelete = confirm("\xBFEst\xE1s seguro que deseas eliminar este post?");
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest(".divPost").remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ const likeButton = document.createElement("button");
+ likeButton.classList.add("like-btn");
+ likeButton.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+ return postForm;
+ };
+ cf(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector(".showPost");
+ textarea.removeAttribute("readonly");
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute("data-id", doc.id);
+ }
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector(".like-btn");
+ buttonLike.innerHTML = `Inicia Sesi\xF3n
+ Reg\xEDstrate
+ Reg\xEDstrate con Google
+ `;
+ const logIn = section.querySelector(".logIn");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const register = section.querySelector(".register");
+ register.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const google = section.querySelector(".google");
+ google.addEventListener("click", () => {
+ loginWithGoogle().then(() => {
+ navigateTo2("/emprende");
+ }).catch(() => {
+ });
+ });
+ return section;
+}
+function login(navigateTo2) {
+ const sectionLogin = document.createElement("section");
+ sectionLogin.classList.add("sectionLogin");
+ sectionLogin.innerHTML = `
+ \xBFNo tienes una cuenta? Reg\xEDstrate
+
+ `;
+ const checkIn = sectionLogin.querySelector(".bottomTextLogin");
+ checkIn.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const formLogin = sectionLogin.querySelector(".formInteraction");
+ formLogin.addEventListener("submit", (e) => {
+ e.preventDefault();
+ const email = sectionLogin.querySelector(".inputEmail").value;
+ const password = sectionLogin.querySelector(".inputPassword").value;
+ signIn(email, password).then(() => {
+ navigateTo2("/emprende");
+ }).catch((err) => {
+ sectionLogin.querySelector(".note1").innerHTML = `${err.message}`;
+ });
+ });
+ return sectionLogin;
+}
+function create(navigateTo2) {
+ const sectionCreate = document.createElement("div");
+ sectionCreate.classList.add("creat");
+ sectionCreate.innerHTML = `
+ \xBFYa tienes cuenta? Iniciar Sesi\xF3n
+
+ `;
+ const logIn = sectionCreate.querySelector(".bottomText");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const form = sectionCreate.querySelector(".formCreateAccount");
+ form.addEventListener("submit", (e) => {
+ e.preventDefault();
+ const email = sectionCreate.querySelector(".card1").value;
+ const password = sectionCreate.querySelector(".card2").value;
+ createUser(email, password).then(() => {
+ navigateTo2("/emprende");
+ }).catch((err) => {
+ sectionCreate.querySelector(".alerta").innerHTML = `${err.message}`;
+ });
+ });
+ return sectionCreate;
+}
+const root = document.getElementById("root");
+root.append(init());
+const routes = [
+ { path: "/", component: init },
+ { path: "/login", component: login },
+ { path: "/register", component: create },
+ { path: "/error", component: mistake },
+ { path: "/emprende", component: home }
+];
+function navigateTo(hash) {
+ const route = routes.find((routeFind) => routeFind.path === hash);
+ if (route && route.component) {
+ window.history.pushState({}, route.path, window.location.origin + route.path);
+ if (root.firstChild) {
+ root.removeChild(root.firstChild);
+ }
+ root.append(route.component(navigateTo));
+ } else {
+ navigateTo("/error");
+ }
+}
+onAuthStateChanged(auth, (user) => {
+ if (user) {
+ navigateTo("/emprende");
+ } else if (window.location.pathname === "/emprende" && user === null) {
+ navigateTo();
+ } else {
+ navigateTo(window.location.pathname);
+ }
+});
diff --git a/dist/assets/index.b9154af1.js b/dist/assets/index.b9154af1.js
new file mode 100644
index 00000000..a10ff9a3
--- /dev/null
+++ b/dist/assets/index.b9154af1.js
@@ -0,0 +1,17990 @@
+(function polyfill() {
+ const relList = document.createElement("link").relList;
+ if (relList && relList.supports && relList.supports("modulepreload")) {
+ return;
+ }
+ for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
+ processPreload(link);
+ }
+ new MutationObserver((mutations) => {
+ for (const mutation of mutations) {
+ if (mutation.type !== "childList") {
+ continue;
+ }
+ for (const node of mutation.addedNodes) {
+ if (node.tagName === "LINK" && node.rel === "modulepreload")
+ processPreload(node);
+ }
+ }
+ }).observe(document, { childList: true, subtree: true });
+ function getFetchOpts(script) {
+ const fetchOpts = {};
+ if (script.integrity)
+ fetchOpts.integrity = script.integrity;
+ if (script.referrerpolicy)
+ fetchOpts.referrerPolicy = script.referrerpolicy;
+ if (script.crossorigin === "use-credentials")
+ fetchOpts.credentials = "include";
+ else if (script.crossorigin === "anonymous")
+ fetchOpts.credentials = "omit";
+ else
+ fetchOpts.credentials = "same-origin";
+ return fetchOpts;
+ }
+ function processPreload(link) {
+ if (link.ep)
+ return;
+ link.ep = true;
+ const fetchOpts = getFetchOpts(link);
+ fetch(link.href, fetchOpts);
+ }
+})();
+const style = "";
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const stringToByteArray$1 = function(str) {
+ const out = [];
+ let p2 = 0;
+ for (let i = 0; i < str.length; i++) {
+ let c = str.charCodeAt(i);
+ if (c < 128) {
+ out[p2++] = c;
+ } else if (c < 2048) {
+ out[p2++] = c >> 6 | 192;
+ out[p2++] = c & 63 | 128;
+ } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+ c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+ out[p2++] = c >> 18 | 240;
+ out[p2++] = c >> 12 & 63 | 128;
+ out[p2++] = c >> 6 & 63 | 128;
+ out[p2++] = c & 63 | 128;
+ } else {
+ out[p2++] = c >> 12 | 224;
+ out[p2++] = c >> 6 & 63 | 128;
+ out[p2++] = c & 63 | 128;
+ }
+ }
+ return out;
+};
+const byteArrayToString = function(bytes) {
+ const out = [];
+ let pos = 0, c = 0;
+ while (pos < bytes.length) {
+ const c1 = bytes[pos++];
+ if (c1 < 128) {
+ out[c++] = String.fromCharCode(c1);
+ } else if (c1 > 191 && c1 < 224) {
+ const c2 = bytes[pos++];
+ out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
+ } else if (c1 > 239 && c1 < 365) {
+ const c2 = bytes[pos++];
+ const c3 = bytes[pos++];
+ const c4 = bytes[pos++];
+ const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
+ out[c++] = String.fromCharCode(55296 + (u >> 10));
+ out[c++] = String.fromCharCode(56320 + (u & 1023));
+ } else {
+ const c2 = bytes[pos++];
+ const c3 = bytes[pos++];
+ out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
+ }
+ }
+ return out.join("");
+};
+const base64 = {
+ byteToCharMap_: null,
+ charToByteMap_: null,
+ byteToCharMapWebSafe_: null,
+ charToByteMapWebSafe_: null,
+ ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+ get ENCODED_VALS() {
+ return this.ENCODED_VALS_BASE + "+/=";
+ },
+ get ENCODED_VALS_WEBSAFE() {
+ return this.ENCODED_VALS_BASE + "-_.";
+ },
+ HAS_NATIVE_SUPPORT: typeof atob === "function",
+ encodeByteArray(input, webSafe) {
+ if (!Array.isArray(input)) {
+ throw Error("encodeByteArray takes an array as a parameter");
+ }
+ this.init_();
+ const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
+ const output = [];
+ for (let i = 0; i < input.length; i += 3) {
+ const byte1 = input[i];
+ const haveByte2 = i + 1 < input.length;
+ const byte2 = haveByte2 ? input[i + 1] : 0;
+ const haveByte3 = i + 2 < input.length;
+ const byte3 = haveByte3 ? input[i + 2] : 0;
+ const outByte1 = byte1 >> 2;
+ const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
+ let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
+ let outByte4 = byte3 & 63;
+ if (!haveByte3) {
+ outByte4 = 64;
+ if (!haveByte2) {
+ outByte3 = 64;
+ }
+ }
+ output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
+ }
+ return output.join("");
+ },
+ encodeString(input, webSafe) {
+ if (this.HAS_NATIVE_SUPPORT && !webSafe) {
+ return btoa(input);
+ }
+ return this.encodeByteArray(stringToByteArray$1(input), webSafe);
+ },
+ decodeString(input, webSafe) {
+ if (this.HAS_NATIVE_SUPPORT && !webSafe) {
+ return atob(input);
+ }
+ return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
+ },
+ decodeStringToByteArray(input, webSafe) {
+ this.init_();
+ const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
+ const output = [];
+ for (let i = 0; i < input.length; ) {
+ const byte1 = charToByteMap[input.charAt(i++)];
+ const haveByte2 = i < input.length;
+ const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
+ ++i;
+ const haveByte3 = i < input.length;
+ const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
+ ++i;
+ const haveByte4 = i < input.length;
+ const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
+ ++i;
+ if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
+ throw new DecodeBase64StringError();
+ }
+ const outByte1 = byte1 << 2 | byte2 >> 4;
+ output.push(outByte1);
+ if (byte3 !== 64) {
+ const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
+ output.push(outByte2);
+ if (byte4 !== 64) {
+ const outByte3 = byte3 << 6 & 192 | byte4;
+ output.push(outByte3);
+ }
+ }
+ }
+ return output;
+ },
+ init_() {
+ if (!this.byteToCharMap_) {
+ this.byteToCharMap_ = {};
+ this.charToByteMap_ = {};
+ this.byteToCharMapWebSafe_ = {};
+ this.charToByteMapWebSafe_ = {};
+ for (let i = 0; i < this.ENCODED_VALS.length; i++) {
+ this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
+ this.charToByteMap_[this.byteToCharMap_[i]] = i;
+ this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
+ this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
+ if (i >= this.ENCODED_VALS_BASE.length) {
+ this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
+ this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
+ }
+ }
+ }
+ }
+};
+class DecodeBase64StringError extends Error {
+ constructor() {
+ super(...arguments);
+ this.name = "DecodeBase64StringError";
+ }
+}
+const base64Encode = function(str) {
+ const utf8Bytes = stringToByteArray$1(str);
+ return base64.encodeByteArray(utf8Bytes, true);
+};
+const base64urlEncodeWithoutPadding = function(str) {
+ return base64Encode(str).replace(/\./g, "");
+};
+const base64Decode = function(str) {
+ try {
+ return base64.decodeString(str, true);
+ } catch (e) {
+ console.error("base64Decode failed: ", e);
+ }
+ return null;
+};
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getGlobal() {
+ if (typeof self !== "undefined") {
+ return self;
+ }
+ if (typeof window !== "undefined") {
+ return window;
+ }
+ if (typeof global !== "undefined") {
+ return global;
+ }
+ throw new Error("Unable to locate global object.");
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;
+const getDefaultsFromEnvVariable = () => {
+ if (typeof process === "undefined" || typeof process.env === "undefined") {
+ return;
+ }
+ const defaultsJsonString = {}.__FIREBASE_DEFAULTS__;
+ if (defaultsJsonString) {
+ return JSON.parse(defaultsJsonString);
+ }
+};
+const getDefaultsFromCookie = () => {
+ if (typeof document === "undefined") {
+ return;
+ }
+ let match;
+ try {
+ match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
+ } catch (e) {
+ return;
+ }
+ const decoded = match && base64Decode(match[1]);
+ return decoded && JSON.parse(decoded);
+};
+const getDefaults = () => {
+ try {
+ return getDefaultsFromGlobal() || getDefaultsFromEnvVariable() || getDefaultsFromCookie();
+ } catch (e) {
+ console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);
+ return;
+ }
+};
+const getDefaultEmulatorHost = (productName) => {
+ var _a2, _b;
+ return (_b = (_a2 = getDefaults()) === null || _a2 === void 0 ? void 0 : _a2.emulatorHosts) === null || _b === void 0 ? void 0 : _b[productName];
+};
+const getDefaultEmulatorHostnameAndPort = (productName) => {
+ const host = getDefaultEmulatorHost(productName);
+ if (!host) {
+ return void 0;
+ }
+ const separatorIndex = host.lastIndexOf(":");
+ if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {
+ throw new Error(`Invalid host ${host} with no separate hostname and port!`);
+ }
+ const port = parseInt(host.substring(separatorIndex + 1), 10);
+ if (host[0] === "[") {
+ return [host.substring(1, separatorIndex - 1), port];
+ } else {
+ return [host.substring(0, separatorIndex), port];
+ }
+};
+const getDefaultAppConfig = () => {
+ var _a2;
+ return (_a2 = getDefaults()) === null || _a2 === void 0 ? void 0 : _a2.config;
+};
+const getExperimentalSetting = (name2) => {
+ var _a2;
+ return (_a2 = getDefaults()) === null || _a2 === void 0 ? void 0 : _a2[`_${name2}`];
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Deferred {
+ constructor() {
+ this.reject = () => {
+ };
+ this.resolve = () => {
+ };
+ this.promise = new Promise((resolve, reject) => {
+ this.resolve = resolve;
+ this.reject = reject;
+ });
+ }
+ wrapCallback(callback) {
+ return (error, value) => {
+ if (error) {
+ this.reject(error);
+ } else {
+ this.resolve(value);
+ }
+ if (typeof callback === "function") {
+ this.promise.catch(() => {
+ });
+ if (callback.length === 1) {
+ callback(error);
+ } else {
+ callback(error, value);
+ }
+ }
+ };
+ }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function createMockUserToken(token, projectId) {
+ if (token.uid) {
+ throw new Error('The "uid" field is no longer supported by mockUserToken. Please use "sub" instead for Firebase Auth User ID.');
+ }
+ const header = {
+ alg: "none",
+ type: "JWT"
+ };
+ const project = projectId || "demo-project";
+ const iat = token.iat || 0;
+ const sub = token.sub || token.user_id;
+ if (!sub) {
+ throw new Error("mockUserToken must contain 'sub' or 'user_id' field!");
+ }
+ const payload = Object.assign({
+ iss: `https://securetoken.google.com/${project}`,
+ aud: project,
+ iat,
+ exp: iat + 3600,
+ auth_time: iat,
+ sub,
+ user_id: sub,
+ firebase: {
+ sign_in_provider: "custom",
+ identities: {}
+ }
+ }, token);
+ const signature = "";
+ return [
+ base64urlEncodeWithoutPadding(JSON.stringify(header)),
+ base64urlEncodeWithoutPadding(JSON.stringify(payload)),
+ signature
+ ].join(".");
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getUA() {
+ if (typeof navigator !== "undefined" && typeof navigator["userAgent"] === "string") {
+ return navigator["userAgent"];
+ } else {
+ return "";
+ }
+}
+function isMobileCordova() {
+ return typeof window !== "undefined" && !!(window["cordova"] || window["phonegap"] || window["PhoneGap"]) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA());
+}
+function isBrowserExtension() {
+ const runtime = typeof chrome === "object" ? chrome.runtime : typeof browser === "object" ? browser.runtime : void 0;
+ return typeof runtime === "object" && runtime.id !== void 0;
+}
+function isReactNative() {
+ return typeof navigator === "object" && navigator["product"] === "ReactNative";
+}
+function isIE() {
+ const ua2 = getUA();
+ return ua2.indexOf("MSIE ") >= 0 || ua2.indexOf("Trident/") >= 0;
+}
+function isIndexedDBAvailable() {
+ try {
+ return typeof indexedDB === "object";
+ } catch (e) {
+ return false;
+ }
+}
+function validateIndexedDBOpenable() {
+ return new Promise((resolve, reject) => {
+ try {
+ let preExist = true;
+ const DB_CHECK_NAME = "validate-browser-context-for-indexeddb-analytics-module";
+ const request = self.indexedDB.open(DB_CHECK_NAME);
+ request.onsuccess = () => {
+ request.result.close();
+ if (!preExist) {
+ self.indexedDB.deleteDatabase(DB_CHECK_NAME);
+ }
+ resolve(true);
+ };
+ request.onupgradeneeded = () => {
+ preExist = false;
+ };
+ request.onerror = () => {
+ var _a2;
+ reject(((_a2 = request.error) === null || _a2 === void 0 ? void 0 : _a2.message) || "");
+ };
+ } catch (error) {
+ reject(error);
+ }
+ });
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ERROR_NAME = "FirebaseError";
+class FirebaseError extends Error {
+ constructor(code, message, customData) {
+ super(message);
+ this.code = code;
+ this.customData = customData;
+ this.name = ERROR_NAME;
+ Object.setPrototypeOf(this, FirebaseError.prototype);
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, ErrorFactory.prototype.create);
+ }
+ }
+}
+class ErrorFactory {
+ constructor(service, serviceName, errors) {
+ this.service = service;
+ this.serviceName = serviceName;
+ this.errors = errors;
+ }
+ create(code, ...data) {
+ const customData = data[0] || {};
+ const fullCode = `${this.service}/${code}`;
+ const template = this.errors[code];
+ const message = template ? replaceTemplate(template, customData) : "Error";
+ const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;
+ const error = new FirebaseError(fullCode, fullMessage, customData);
+ return error;
+ }
+}
+function replaceTemplate(template, data) {
+ return template.replace(PATTERN, (_, key) => {
+ const value = data[key];
+ return value != null ? String(value) : `<${key}?>`;
+ });
+}
+const PATTERN = /\{\$([^}]+)}/g;
+function isEmpty(obj) {
+ for (const key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) {
+ return false;
+ }
+ }
+ return true;
+}
+function deepEqual(a, b2) {
+ if (a === b2) {
+ return true;
+ }
+ const aKeys = Object.keys(a);
+ const bKeys = Object.keys(b2);
+ for (const k2 of aKeys) {
+ if (!bKeys.includes(k2)) {
+ return false;
+ }
+ const aProp = a[k2];
+ const bProp = b2[k2];
+ if (isObject(aProp) && isObject(bProp)) {
+ if (!deepEqual(aProp, bProp)) {
+ return false;
+ }
+ } else if (aProp !== bProp) {
+ return false;
+ }
+ }
+ for (const k2 of bKeys) {
+ if (!aKeys.includes(k2)) {
+ return false;
+ }
+ }
+ return true;
+}
+function isObject(thing) {
+ return thing !== null && typeof thing === "object";
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function querystring(querystringParams) {
+ const params = [];
+ for (const [key, value] of Object.entries(querystringParams)) {
+ if (Array.isArray(value)) {
+ value.forEach((arrayVal) => {
+ params.push(encodeURIComponent(key) + "=" + encodeURIComponent(arrayVal));
+ });
+ } else {
+ params.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
+ }
+ }
+ return params.length ? "&" + params.join("&") : "";
+}
+function querystringDecode(querystring2) {
+ const obj = {};
+ const tokens = querystring2.replace(/^\?/, "").split("&");
+ tokens.forEach((token) => {
+ if (token) {
+ const [key, value] = token.split("=");
+ obj[decodeURIComponent(key)] = decodeURIComponent(value);
+ }
+ });
+ return obj;
+}
+function extractQuerystring(url) {
+ const queryStart = url.indexOf("?");
+ if (!queryStart) {
+ return "";
+ }
+ const fragmentStart = url.indexOf("#", queryStart);
+ return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : void 0);
+}
+function createSubscribe(executor, onNoObservers) {
+ const proxy = new ObserverProxy(executor, onNoObservers);
+ return proxy.subscribe.bind(proxy);
+}
+class ObserverProxy {
+ constructor(executor, onNoObservers) {
+ this.observers = [];
+ this.unsubscribes = [];
+ this.observerCount = 0;
+ this.task = Promise.resolve();
+ this.finalized = false;
+ this.onNoObservers = onNoObservers;
+ this.task.then(() => {
+ executor(this);
+ }).catch((e) => {
+ this.error(e);
+ });
+ }
+ next(value) {
+ this.forEachObserver((observer) => {
+ observer.next(value);
+ });
+ }
+ error(error) {
+ this.forEachObserver((observer) => {
+ observer.error(error);
+ });
+ this.close(error);
+ }
+ complete() {
+ this.forEachObserver((observer) => {
+ observer.complete();
+ });
+ this.close();
+ }
+ subscribe(nextOrObserver, error, complete) {
+ let observer;
+ if (nextOrObserver === void 0 && error === void 0 && complete === void 0) {
+ throw new Error("Missing Observer.");
+ }
+ if (implementsAnyMethods(nextOrObserver, [
+ "next",
+ "error",
+ "complete"
+ ])) {
+ observer = nextOrObserver;
+ } else {
+ observer = {
+ next: nextOrObserver,
+ error,
+ complete
+ };
+ }
+ if (observer.next === void 0) {
+ observer.next = noop;
+ }
+ if (observer.error === void 0) {
+ observer.error = noop;
+ }
+ if (observer.complete === void 0) {
+ observer.complete = noop;
+ }
+ const unsub = this.unsubscribeOne.bind(this, this.observers.length);
+ if (this.finalized) {
+ this.task.then(() => {
+ try {
+ if (this.finalError) {
+ observer.error(this.finalError);
+ } else {
+ observer.complete();
+ }
+ } catch (e) {
+ }
+ return;
+ });
+ }
+ this.observers.push(observer);
+ return unsub;
+ }
+ unsubscribeOne(i) {
+ if (this.observers === void 0 || this.observers[i] === void 0) {
+ return;
+ }
+ delete this.observers[i];
+ this.observerCount -= 1;
+ if (this.observerCount === 0 && this.onNoObservers !== void 0) {
+ this.onNoObservers(this);
+ }
+ }
+ forEachObserver(fn2) {
+ if (this.finalized) {
+ return;
+ }
+ for (let i = 0; i < this.observers.length; i++) {
+ this.sendOne(i, fn2);
+ }
+ }
+ sendOne(i, fn2) {
+ this.task.then(() => {
+ if (this.observers !== void 0 && this.observers[i] !== void 0) {
+ try {
+ fn2(this.observers[i]);
+ } catch (e) {
+ if (typeof console !== "undefined" && console.error) {
+ console.error(e);
+ }
+ }
+ }
+ });
+ }
+ close(err) {
+ if (this.finalized) {
+ return;
+ }
+ this.finalized = true;
+ if (err !== void 0) {
+ this.finalError = err;
+ }
+ this.task.then(() => {
+ this.observers = void 0;
+ this.onNoObservers = void 0;
+ });
+ }
+}
+function implementsAnyMethods(obj, methods) {
+ if (typeof obj !== "object" || obj === null) {
+ return false;
+ }
+ for (const method of methods) {
+ if (method in obj && typeof obj[method] === "function") {
+ return true;
+ }
+ }
+ return false;
+}
+function noop() {
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getModularInstance(service) {
+ if (service && service._delegate) {
+ return service._delegate;
+ } else {
+ return service;
+ }
+}
+class Component {
+ constructor(name2, instanceFactory, type) {
+ this.name = name2;
+ this.instanceFactory = instanceFactory;
+ this.type = type;
+ this.multipleInstances = false;
+ this.serviceProps = {};
+ this.instantiationMode = "LAZY";
+ this.onInstanceCreated = null;
+ }
+ setInstantiationMode(mode) {
+ this.instantiationMode = mode;
+ return this;
+ }
+ setMultipleInstances(multipleInstances) {
+ this.multipleInstances = multipleInstances;
+ return this;
+ }
+ setServiceProps(props) {
+ this.serviceProps = props;
+ return this;
+ }
+ setInstanceCreatedCallback(callback) {
+ this.onInstanceCreated = callback;
+ return this;
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_ENTRY_NAME$1 = "[DEFAULT]";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Provider {
+ constructor(name2, container) {
+ this.name = name2;
+ this.container = container;
+ this.component = null;
+ this.instances = /* @__PURE__ */ new Map();
+ this.instancesDeferred = /* @__PURE__ */ new Map();
+ this.instancesOptions = /* @__PURE__ */ new Map();
+ this.onInitCallbacks = /* @__PURE__ */ new Map();
+ }
+ get(identifier) {
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
+ if (!this.instancesDeferred.has(normalizedIdentifier)) {
+ const deferred = new Deferred();
+ this.instancesDeferred.set(normalizedIdentifier, deferred);
+ if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
+ try {
+ const instance = this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier
+ });
+ if (instance) {
+ deferred.resolve(instance);
+ }
+ } catch (e) {
+ }
+ }
+ }
+ return this.instancesDeferred.get(normalizedIdentifier).promise;
+ }
+ getImmediate(options) {
+ var _a2;
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier);
+ const optional = (_a2 = options === null || options === void 0 ? void 0 : options.optional) !== null && _a2 !== void 0 ? _a2 : false;
+ if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
+ try {
+ return this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier
+ });
+ } catch (e) {
+ if (optional) {
+ return null;
+ } else {
+ throw e;
+ }
+ }
+ } else {
+ if (optional) {
+ return null;
+ } else {
+ throw Error(`Service ${this.name} is not available`);
+ }
+ }
+ }
+ getComponent() {
+ return this.component;
+ }
+ setComponent(component) {
+ if (component.name !== this.name) {
+ throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
+ }
+ if (this.component) {
+ throw Error(`Component for ${this.name} has already been provided`);
+ }
+ this.component = component;
+ if (!this.shouldAutoInitialize()) {
+ return;
+ }
+ if (isComponentEager(component)) {
+ try {
+ this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME$1 });
+ } catch (e) {
+ }
+ }
+ for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
+ try {
+ const instance = this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier
+ });
+ instanceDeferred.resolve(instance);
+ } catch (e) {
+ }
+ }
+ }
+ clearInstance(identifier = DEFAULT_ENTRY_NAME$1) {
+ this.instancesDeferred.delete(identifier);
+ this.instancesOptions.delete(identifier);
+ this.instances.delete(identifier);
+ }
+ async delete() {
+ const services = Array.from(this.instances.values());
+ await Promise.all([
+ ...services.filter((service) => "INTERNAL" in service).map((service) => service.INTERNAL.delete()),
+ ...services.filter((service) => "_delete" in service).map((service) => service._delete())
+ ]);
+ }
+ isComponentSet() {
+ return this.component != null;
+ }
+ isInitialized(identifier = DEFAULT_ENTRY_NAME$1) {
+ return this.instances.has(identifier);
+ }
+ getOptions(identifier = DEFAULT_ENTRY_NAME$1) {
+ return this.instancesOptions.get(identifier) || {};
+ }
+ initialize(opts = {}) {
+ const { options = {} } = opts;
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
+ if (this.isInitialized(normalizedIdentifier)) {
+ throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
+ }
+ if (!this.isComponentSet()) {
+ throw Error(`Component ${this.name} has not been registered yet`);
+ }
+ const instance = this.getOrInitializeService({
+ instanceIdentifier: normalizedIdentifier,
+ options
+ });
+ for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
+ const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
+ if (normalizedIdentifier === normalizedDeferredIdentifier) {
+ instanceDeferred.resolve(instance);
+ }
+ }
+ return instance;
+ }
+ onInit(callback, identifier) {
+ var _a2;
+ const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
+ const existingCallbacks = (_a2 = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a2 !== void 0 ? _a2 : /* @__PURE__ */ new Set();
+ existingCallbacks.add(callback);
+ this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
+ const existingInstance = this.instances.get(normalizedIdentifier);
+ if (existingInstance) {
+ callback(existingInstance, normalizedIdentifier);
+ }
+ return () => {
+ existingCallbacks.delete(callback);
+ };
+ }
+ invokeOnInitCallbacks(instance, identifier) {
+ const callbacks = this.onInitCallbacks.get(identifier);
+ if (!callbacks) {
+ return;
+ }
+ for (const callback of callbacks) {
+ try {
+ callback(instance, identifier);
+ } catch (_a2) {
+ }
+ }
+ }
+ getOrInitializeService({ instanceIdentifier, options = {} }) {
+ let instance = this.instances.get(instanceIdentifier);
+ if (!instance && this.component) {
+ instance = this.component.instanceFactory(this.container, {
+ instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),
+ options
+ });
+ this.instances.set(instanceIdentifier, instance);
+ this.instancesOptions.set(instanceIdentifier, options);
+ this.invokeOnInitCallbacks(instance, instanceIdentifier);
+ if (this.component.onInstanceCreated) {
+ try {
+ this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
+ } catch (_a2) {
+ }
+ }
+ }
+ return instance || null;
+ }
+ normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME$1) {
+ if (this.component) {
+ return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME$1;
+ } else {
+ return identifier;
+ }
+ }
+ shouldAutoInitialize() {
+ return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+ }
+}
+function normalizeIdentifierForFactory(identifier) {
+ return identifier === DEFAULT_ENTRY_NAME$1 ? void 0 : identifier;
+}
+function isComponentEager(component) {
+ return component.instantiationMode === "EAGER";
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ComponentContainer {
+ constructor(name2) {
+ this.name = name2;
+ this.providers = /* @__PURE__ */ new Map();
+ }
+ addComponent(component) {
+ const provider2 = this.getProvider(component.name);
+ if (provider2.isComponentSet()) {
+ throw new Error(`Component ${component.name} has already been registered with ${this.name}`);
+ }
+ provider2.setComponent(component);
+ }
+ addOrOverwriteComponent(component) {
+ const provider2 = this.getProvider(component.name);
+ if (provider2.isComponentSet()) {
+ this.providers.delete(component.name);
+ }
+ this.addComponent(component);
+ }
+ getProvider(name2) {
+ if (this.providers.has(name2)) {
+ return this.providers.get(name2);
+ }
+ const provider2 = new Provider(name2, this);
+ this.providers.set(name2, provider2);
+ return provider2;
+ }
+ getProviders() {
+ return Array.from(this.providers.values());
+ }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var LogLevel;
+(function(LogLevel2) {
+ LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+ LogLevel2[LogLevel2["VERBOSE"] = 1] = "VERBOSE";
+ LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+ LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
+ LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
+ LogLevel2[LogLevel2["SILENT"] = 5] = "SILENT";
+})(LogLevel || (LogLevel = {}));
+const levelStringToEnum = {
+ "debug": LogLevel.DEBUG,
+ "verbose": LogLevel.VERBOSE,
+ "info": LogLevel.INFO,
+ "warn": LogLevel.WARN,
+ "error": LogLevel.ERROR,
+ "silent": LogLevel.SILENT
+};
+const defaultLogLevel = LogLevel.INFO;
+const ConsoleMethod = {
+ [LogLevel.DEBUG]: "log",
+ [LogLevel.VERBOSE]: "log",
+ [LogLevel.INFO]: "info",
+ [LogLevel.WARN]: "warn",
+ [LogLevel.ERROR]: "error"
+};
+const defaultLogHandler = (instance, logType, ...args) => {
+ if (logType < instance.logLevel) {
+ return;
+ }
+ const now = new Date().toISOString();
+ const method = ConsoleMethod[logType];
+ if (method) {
+ console[method](`[${now}] ${instance.name}:`, ...args);
+ } else {
+ throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
+ }
+};
+class Logger {
+ constructor(name2) {
+ this.name = name2;
+ this._logLevel = defaultLogLevel;
+ this._logHandler = defaultLogHandler;
+ this._userLogHandler = null;
+ }
+ get logLevel() {
+ return this._logLevel;
+ }
+ set logLevel(val) {
+ if (!(val in LogLevel)) {
+ throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
+ }
+ this._logLevel = val;
+ }
+ setLogLevel(val) {
+ this._logLevel = typeof val === "string" ? levelStringToEnum[val] : val;
+ }
+ get logHandler() {
+ return this._logHandler;
+ }
+ set logHandler(val) {
+ if (typeof val !== "function") {
+ throw new TypeError("Value assigned to `logHandler` must be a function");
+ }
+ this._logHandler = val;
+ }
+ get userLogHandler() {
+ return this._userLogHandler;
+ }
+ set userLogHandler(val) {
+ this._userLogHandler = val;
+ }
+ debug(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
+ this._logHandler(this, LogLevel.DEBUG, ...args);
+ }
+ log(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);
+ this._logHandler(this, LogLevel.VERBOSE, ...args);
+ }
+ info(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
+ this._logHandler(this, LogLevel.INFO, ...args);
+ }
+ warn(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
+ this._logHandler(this, LogLevel.WARN, ...args);
+ }
+ error(...args) {
+ this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
+ this._logHandler(this, LogLevel.ERROR, ...args);
+ }
+}
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+ return idbProxyableTypes || (idbProxyableTypes = [
+ IDBDatabase,
+ IDBObjectStore,
+ IDBIndex,
+ IDBCursor,
+ IDBTransaction
+ ]);
+}
+function getCursorAdvanceMethods() {
+ return cursorAdvanceMethods || (cursorAdvanceMethods = [
+ IDBCursor.prototype.advance,
+ IDBCursor.prototype.continue,
+ IDBCursor.prototype.continuePrimaryKey
+ ]);
+}
+const cursorRequestMap = /* @__PURE__ */ new WeakMap();
+const transactionDoneMap = /* @__PURE__ */ new WeakMap();
+const transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
+const transformCache = /* @__PURE__ */ new WeakMap();
+const reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+ const promise = new Promise((resolve, reject) => {
+ const unlisten = () => {
+ request.removeEventListener("success", success);
+ request.removeEventListener("error", error);
+ };
+ const success = () => {
+ resolve(wrap(request.result));
+ unlisten();
+ };
+ const error = () => {
+ reject(request.error);
+ unlisten();
+ };
+ request.addEventListener("success", success);
+ request.addEventListener("error", error);
+ });
+ promise.then((value) => {
+ if (value instanceof IDBCursor) {
+ cursorRequestMap.set(value, request);
+ }
+ }).catch(() => {
+ });
+ reverseTransformCache.set(promise, request);
+ return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+ if (transactionDoneMap.has(tx))
+ return;
+ const done = new Promise((resolve, reject) => {
+ const unlisten = () => {
+ tx.removeEventListener("complete", complete);
+ tx.removeEventListener("error", error);
+ tx.removeEventListener("abort", error);
+ };
+ const complete = () => {
+ resolve();
+ unlisten();
+ };
+ const error = () => {
+ reject(tx.error || new DOMException("AbortError", "AbortError"));
+ unlisten();
+ };
+ tx.addEventListener("complete", complete);
+ tx.addEventListener("error", error);
+ tx.addEventListener("abort", error);
+ });
+ transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+ get(target, prop, receiver) {
+ if (target instanceof IDBTransaction) {
+ if (prop === "done")
+ return transactionDoneMap.get(target);
+ if (prop === "objectStoreNames") {
+ return target.objectStoreNames || transactionStoreNamesMap.get(target);
+ }
+ if (prop === "store") {
+ return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+ }
+ }
+ return wrap(target[prop]);
+ },
+ set(target, prop, value) {
+ target[prop] = value;
+ return true;
+ },
+ has(target, prop) {
+ if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+ return true;
+ }
+ return prop in target;
+ }
+};
+function replaceTraps(callback) {
+ idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+ if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
+ return function(storeNames, ...args) {
+ const tx = func.call(unwrap(this), storeNames, ...args);
+ transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+ return wrap(tx);
+ };
+ }
+ if (getCursorAdvanceMethods().includes(func)) {
+ return function(...args) {
+ func.apply(unwrap(this), args);
+ return wrap(cursorRequestMap.get(this));
+ };
+ }
+ return function(...args) {
+ return wrap(func.apply(unwrap(this), args));
+ };
+}
+function transformCachableValue(value) {
+ if (typeof value === "function")
+ return wrapFunction(value);
+ if (value instanceof IDBTransaction)
+ cacheDonePromiseForTransaction(value);
+ if (instanceOfAny(value, getIdbProxyableTypes()))
+ return new Proxy(value, idbProxyTraps);
+ return value;
+}
+function wrap(value) {
+ if (value instanceof IDBRequest)
+ return promisifyRequest(value);
+ if (transformCache.has(value))
+ return transformCache.get(value);
+ const newValue = transformCachableValue(value);
+ if (newValue !== value) {
+ transformCache.set(value, newValue);
+ reverseTransformCache.set(newValue, value);
+ }
+ return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name2, version2, { blocked, upgrade, blocking, terminated } = {}) {
+ const request = indexedDB.open(name2, version2);
+ const openPromise = wrap(request);
+ if (upgrade) {
+ request.addEventListener("upgradeneeded", (event) => {
+ upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction));
+ });
+ }
+ if (blocked)
+ request.addEventListener("blocked", () => blocked());
+ openPromise.then((db2) => {
+ if (terminated)
+ db2.addEventListener("close", () => terminated());
+ if (blocking)
+ db2.addEventListener("versionchange", () => blocking());
+ }).catch(() => {
+ });
+ return openPromise;
+}
+const readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+const writeMethods = ["put", "add", "delete", "clear"];
+const cachedMethods = /* @__PURE__ */ new Map();
+function getMethod(target, prop) {
+ if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+ return;
+ }
+ if (cachedMethods.get(prop))
+ return cachedMethods.get(prop);
+ const targetFuncName = prop.replace(/FromIndex$/, "");
+ const useIndex = prop !== targetFuncName;
+ const isWrite = writeMethods.includes(targetFuncName);
+ if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+ return;
+ }
+ const method = async function(storeName, ...args) {
+ const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+ let target2 = tx.store;
+ if (useIndex)
+ target2 = target2.index(args.shift());
+ return (await Promise.all([
+ target2[targetFuncName](...args),
+ isWrite && tx.done
+ ]))[0];
+ };
+ cachedMethods.set(prop, method);
+ return method;
+}
+replaceTraps((oldTraps) => ({
+ ...oldTraps,
+ get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+ has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class PlatformLoggerServiceImpl {
+ constructor(container) {
+ this.container = container;
+ }
+ getPlatformInfoString() {
+ const providers = this.container.getProviders();
+ return providers.map((provider2) => {
+ if (isVersionServiceProvider(provider2)) {
+ const service = provider2.getImmediate();
+ return `${service.library}/${service.version}`;
+ } else {
+ return null;
+ }
+ }).filter((logString) => logString).join(" ");
+ }
+}
+function isVersionServiceProvider(provider2) {
+ const component = provider2.getComponent();
+ return (component === null || component === void 0 ? void 0 : component.type) === "VERSION";
+}
+const name$o = "@firebase/app";
+const version$1$1 = "0.9.7";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger = new Logger("@firebase/app");
+const name$n = "@firebase/app-compat";
+const name$m = "@firebase/analytics-compat";
+const name$l = "@firebase/analytics";
+const name$k = "@firebase/app-check-compat";
+const name$j = "@firebase/app-check";
+const name$i = "@firebase/auth";
+const name$h = "@firebase/auth-compat";
+const name$g = "@firebase/database";
+const name$f = "@firebase/database-compat";
+const name$e = "@firebase/functions";
+const name$d = "@firebase/functions-compat";
+const name$c = "@firebase/installations";
+const name$b = "@firebase/installations-compat";
+const name$a = "@firebase/messaging";
+const name$9 = "@firebase/messaging-compat";
+const name$8 = "@firebase/performance";
+const name$7 = "@firebase/performance-compat";
+const name$6 = "@firebase/remote-config";
+const name$5 = "@firebase/remote-config-compat";
+const name$4 = "@firebase/storage";
+const name$3 = "@firebase/storage-compat";
+const name$2 = "@firebase/firestore";
+const name$1$1 = "@firebase/firestore-compat";
+const name$p = "firebase";
+const version$2 = "9.19.1";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_ENTRY_NAME = "[DEFAULT]";
+const PLATFORM_LOG_STRING = {
+ [name$o]: "fire-core",
+ [name$n]: "fire-core-compat",
+ [name$l]: "fire-analytics",
+ [name$m]: "fire-analytics-compat",
+ [name$j]: "fire-app-check",
+ [name$k]: "fire-app-check-compat",
+ [name$i]: "fire-auth",
+ [name$h]: "fire-auth-compat",
+ [name$g]: "fire-rtdb",
+ [name$f]: "fire-rtdb-compat",
+ [name$e]: "fire-fn",
+ [name$d]: "fire-fn-compat",
+ [name$c]: "fire-iid",
+ [name$b]: "fire-iid-compat",
+ [name$a]: "fire-fcm",
+ [name$9]: "fire-fcm-compat",
+ [name$8]: "fire-perf",
+ [name$7]: "fire-perf-compat",
+ [name$6]: "fire-rc",
+ [name$5]: "fire-rc-compat",
+ [name$4]: "fire-gcs",
+ [name$3]: "fire-gcs-compat",
+ [name$2]: "fire-fst",
+ [name$1$1]: "fire-fst-compat",
+ "fire-js": "fire-js",
+ [name$p]: "fire-js-all"
+};
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const _apps = /* @__PURE__ */ new Map();
+const _components = /* @__PURE__ */ new Map();
+function _addComponent(app2, component) {
+ try {
+ app2.container.addComponent(component);
+ } catch (e) {
+ logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app2.name}`, e);
+ }
+}
+function _registerComponent(component) {
+ const componentName = component.name;
+ if (_components.has(componentName)) {
+ logger.debug(`There were multiple attempts to register component ${componentName}.`);
+ return false;
+ }
+ _components.set(componentName, component);
+ for (const app2 of _apps.values()) {
+ _addComponent(app2, component);
+ }
+ return true;
+}
+function _getProvider(app2, name2) {
+ const heartbeatController = app2.container.getProvider("heartbeat").getImmediate({ optional: true });
+ if (heartbeatController) {
+ void heartbeatController.triggerHeartbeat();
+ }
+ return app2.container.getProvider(name2);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ERRORS = {
+ ["no-app"]: "No Firebase App '{$appName}' has been created - call Firebase App.initializeApp()",
+ ["bad-app-name"]: "Illegal App name: '{$appName}",
+ ["duplicate-app"]: "Firebase App named '{$appName}' already exists with different options or config",
+ ["app-deleted"]: "Firebase App named '{$appName}' already deleted",
+ ["no-options"]: "Need to provide options, when not being deployed to hosting via source.",
+ ["invalid-app-argument"]: "firebase.{$appName}() takes either no argument or a Firebase App instance.",
+ ["invalid-log-argument"]: "First argument to `onLog` must be null or a function.",
+ ["idb-open"]: "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
+ ["idb-get"]: "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
+ ["idb-set"]: "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
+ ["idb-delete"]: "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}."
+};
+const ERROR_FACTORY = new ErrorFactory("app", "Firebase", ERRORS);
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FirebaseAppImpl {
+ constructor(options, config, container) {
+ this._isDeleted = false;
+ this._options = Object.assign({}, options);
+ this._config = Object.assign({}, config);
+ this._name = config.name;
+ this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;
+ this._container = container;
+ this.container.addComponent(new Component("app", () => this, "PUBLIC"));
+ }
+ get automaticDataCollectionEnabled() {
+ this.checkDestroyed();
+ return this._automaticDataCollectionEnabled;
+ }
+ set automaticDataCollectionEnabled(val) {
+ this.checkDestroyed();
+ this._automaticDataCollectionEnabled = val;
+ }
+ get name() {
+ this.checkDestroyed();
+ return this._name;
+ }
+ get options() {
+ this.checkDestroyed();
+ return this._options;
+ }
+ get config() {
+ this.checkDestroyed();
+ return this._config;
+ }
+ get container() {
+ return this._container;
+ }
+ get isDeleted() {
+ return this._isDeleted;
+ }
+ set isDeleted(val) {
+ this._isDeleted = val;
+ }
+ checkDestroyed() {
+ if (this.isDeleted) {
+ throw ERROR_FACTORY.create("app-deleted", { appName: this._name });
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const SDK_VERSION = version$2;
+function initializeApp(_options, rawConfig = {}) {
+ let options = _options;
+ if (typeof rawConfig !== "object") {
+ const name3 = rawConfig;
+ rawConfig = { name: name3 };
+ }
+ const config = Object.assign({ name: DEFAULT_ENTRY_NAME, automaticDataCollectionEnabled: false }, rawConfig);
+ const name2 = config.name;
+ if (typeof name2 !== "string" || !name2) {
+ throw ERROR_FACTORY.create("bad-app-name", {
+ appName: String(name2)
+ });
+ }
+ options || (options = getDefaultAppConfig());
+ if (!options) {
+ throw ERROR_FACTORY.create("no-options");
+ }
+ const existingApp = _apps.get(name2);
+ if (existingApp) {
+ if (deepEqual(options, existingApp.options) && deepEqual(config, existingApp.config)) {
+ return existingApp;
+ } else {
+ throw ERROR_FACTORY.create("duplicate-app", { appName: name2 });
+ }
+ }
+ const container = new ComponentContainer(name2);
+ for (const component of _components.values()) {
+ container.addComponent(component);
+ }
+ const newApp = new FirebaseAppImpl(options, config, container);
+ _apps.set(name2, newApp);
+ return newApp;
+}
+function getApp(name2 = DEFAULT_ENTRY_NAME) {
+ const app2 = _apps.get(name2);
+ if (!app2 && name2 === DEFAULT_ENTRY_NAME) {
+ return initializeApp();
+ }
+ if (!app2) {
+ throw ERROR_FACTORY.create("no-app", { appName: name2 });
+ }
+ return app2;
+}
+function registerVersion(libraryKeyOrName, version2, variant) {
+ var _a2;
+ let library = (_a2 = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a2 !== void 0 ? _a2 : libraryKeyOrName;
+ if (variant) {
+ library += `-${variant}`;
+ }
+ const libraryMismatch = library.match(/\s|\//);
+ const versionMismatch = version2.match(/\s|\//);
+ if (libraryMismatch || versionMismatch) {
+ const warning = [
+ `Unable to register library "${library}" with version "${version2}":`
+ ];
+ if (libraryMismatch) {
+ warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
+ }
+ if (libraryMismatch && versionMismatch) {
+ warning.push("and");
+ }
+ if (versionMismatch) {
+ warning.push(`version name "${version2}" contains illegal characters (whitespace or "/")`);
+ }
+ logger.warn(warning.join(" "));
+ return;
+ }
+ _registerComponent(new Component(`${library}-version`, () => ({ library, version: version2 }), "VERSION"));
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DB_NAME$1 = "firebase-heartbeat-database";
+const DB_VERSION$1 = 1;
+const STORE_NAME = "firebase-heartbeat-store";
+let dbPromise = null;
+function getDbPromise() {
+ if (!dbPromise) {
+ dbPromise = openDB(DB_NAME$1, DB_VERSION$1, {
+ upgrade: (db2, oldVersion) => {
+ switch (oldVersion) {
+ case 0:
+ db2.createObjectStore(STORE_NAME);
+ }
+ }
+ }).catch((e) => {
+ throw ERROR_FACTORY.create("idb-open", {
+ originalErrorMessage: e.message
+ });
+ });
+ }
+ return dbPromise;
+}
+async function readHeartbeatsFromIndexedDB(app2) {
+ try {
+ const db2 = await getDbPromise();
+ return db2.transaction(STORE_NAME).objectStore(STORE_NAME).get(computeKey(app2));
+ } catch (e) {
+ if (e instanceof FirebaseError) {
+ logger.warn(e.message);
+ } else {
+ const idbGetError = ERROR_FACTORY.create("idb-get", {
+ originalErrorMessage: e === null || e === void 0 ? void 0 : e.message
+ });
+ logger.warn(idbGetError.message);
+ }
+ }
+}
+async function writeHeartbeatsToIndexedDB(app2, heartbeatObject) {
+ try {
+ const db2 = await getDbPromise();
+ const tx = db2.transaction(STORE_NAME, "readwrite");
+ const objectStore = tx.objectStore(STORE_NAME);
+ await objectStore.put(heartbeatObject, computeKey(app2));
+ return tx.done;
+ } catch (e) {
+ if (e instanceof FirebaseError) {
+ logger.warn(e.message);
+ } else {
+ const idbGetError = ERROR_FACTORY.create("idb-set", {
+ originalErrorMessage: e === null || e === void 0 ? void 0 : e.message
+ });
+ logger.warn(idbGetError.message);
+ }
+ }
+}
+function computeKey(app2) {
+ return `${app2.name}!${app2.options.appId}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const MAX_HEADER_BYTES = 1024;
+const STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1e3;
+class HeartbeatServiceImpl {
+ constructor(container) {
+ this.container = container;
+ this._heartbeatsCache = null;
+ const app2 = this.container.getProvider("app").getImmediate();
+ this._storage = new HeartbeatStorageImpl(app2);
+ this._heartbeatsCachePromise = this._storage.read().then((result) => {
+ this._heartbeatsCache = result;
+ return result;
+ });
+ }
+ async triggerHeartbeat() {
+ const platformLogger = this.container.getProvider("platform-logger").getImmediate();
+ const agent = platformLogger.getPlatformInfoString();
+ const date = getUTCDateString();
+ if (this._heartbeatsCache === null) {
+ this._heartbeatsCache = await this._heartbeatsCachePromise;
+ }
+ if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some((singleDateHeartbeat) => singleDateHeartbeat.date === date)) {
+ return;
+ } else {
+ this._heartbeatsCache.heartbeats.push({ date, agent });
+ }
+ this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter((singleDateHeartbeat) => {
+ const hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();
+ const now = Date.now();
+ return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;
+ });
+ return this._storage.overwrite(this._heartbeatsCache);
+ }
+ async getHeartbeatsHeader() {
+ if (this._heartbeatsCache === null) {
+ await this._heartbeatsCachePromise;
+ }
+ if (this._heartbeatsCache === null || this._heartbeatsCache.heartbeats.length === 0) {
+ return "";
+ }
+ const date = getUTCDateString();
+ const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
+ const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
+ this._heartbeatsCache.lastSentHeartbeatDate = date;
+ if (unsentEntries.length > 0) {
+ this._heartbeatsCache.heartbeats = unsentEntries;
+ await this._storage.overwrite(this._heartbeatsCache);
+ } else {
+ this._heartbeatsCache.heartbeats = [];
+ void this._storage.overwrite(this._heartbeatsCache);
+ }
+ return headerString;
+ }
+}
+function getUTCDateString() {
+ const today = new Date();
+ return today.toISOString().substring(0, 10);
+}
+function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
+ const heartbeatsToSend = [];
+ let unsentEntries = heartbeatsCache.slice();
+ for (const singleDateHeartbeat of heartbeatsCache) {
+ const heartbeatEntry = heartbeatsToSend.find((hb2) => hb2.agent === singleDateHeartbeat.agent);
+ if (!heartbeatEntry) {
+ heartbeatsToSend.push({
+ agent: singleDateHeartbeat.agent,
+ dates: [singleDateHeartbeat.date]
+ });
+ if (countBytes(heartbeatsToSend) > maxSize) {
+ heartbeatsToSend.pop();
+ break;
+ }
+ } else {
+ heartbeatEntry.dates.push(singleDateHeartbeat.date);
+ if (countBytes(heartbeatsToSend) > maxSize) {
+ heartbeatEntry.dates.pop();
+ break;
+ }
+ }
+ unsentEntries = unsentEntries.slice(1);
+ }
+ return {
+ heartbeatsToSend,
+ unsentEntries
+ };
+}
+class HeartbeatStorageImpl {
+ constructor(app2) {
+ this.app = app2;
+ this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+ }
+ async runIndexedDBEnvironmentCheck() {
+ if (!isIndexedDBAvailable()) {
+ return false;
+ } else {
+ return validateIndexedDBOpenable().then(() => true).catch(() => false);
+ }
+ }
+ async read() {
+ const canUseIndexedDB = await this._canUseIndexedDBPromise;
+ if (!canUseIndexedDB) {
+ return { heartbeats: [] };
+ } else {
+ const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
+ return idbHeartbeatObject || { heartbeats: [] };
+ }
+ }
+ async overwrite(heartbeatsObject) {
+ var _a2;
+ const canUseIndexedDB = await this._canUseIndexedDBPromise;
+ if (!canUseIndexedDB) {
+ return;
+ } else {
+ const existingHeartbeatsObject = await this.read();
+ return writeHeartbeatsToIndexedDB(this.app, {
+ lastSentHeartbeatDate: (_a2 = heartbeatsObject.lastSentHeartbeatDate) !== null && _a2 !== void 0 ? _a2 : existingHeartbeatsObject.lastSentHeartbeatDate,
+ heartbeats: heartbeatsObject.heartbeats
+ });
+ }
+ }
+ async add(heartbeatsObject) {
+ var _a2;
+ const canUseIndexedDB = await this._canUseIndexedDBPromise;
+ if (!canUseIndexedDB) {
+ return;
+ } else {
+ const existingHeartbeatsObject = await this.read();
+ return writeHeartbeatsToIndexedDB(this.app, {
+ lastSentHeartbeatDate: (_a2 = heartbeatsObject.lastSentHeartbeatDate) !== null && _a2 !== void 0 ? _a2 : existingHeartbeatsObject.lastSentHeartbeatDate,
+ heartbeats: [
+ ...existingHeartbeatsObject.heartbeats,
+ ...heartbeatsObject.heartbeats
+ ]
+ });
+ }
+ }
+}
+function countBytes(heartbeatsCache) {
+ return base64urlEncodeWithoutPadding(
+ JSON.stringify({ version: 2, heartbeats: heartbeatsCache })
+ ).length;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function registerCoreComponents(variant) {
+ _registerComponent(new Component("platform-logger", (container) => new PlatformLoggerServiceImpl(container), "PRIVATE"));
+ _registerComponent(new Component("heartbeat", (container) => new HeartbeatServiceImpl(container), "PRIVATE"));
+ registerVersion(name$o, version$1$1, variant);
+ registerVersion(name$o, version$1$1, "esm2017");
+ registerVersion("fire-js", "");
+}
+registerCoreComponents("");
+function __rest(s, e) {
+ var t2 = {};
+ for (var p2 in s)
+ if (Object.prototype.hasOwnProperty.call(s, p2) && e.indexOf(p2) < 0)
+ t2[p2] = s[p2];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p2 = Object.getOwnPropertySymbols(s); i < p2.length; i++) {
+ if (e.indexOf(p2[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p2[i]))
+ t2[p2[i]] = s[p2[i]];
+ }
+ return t2;
+}
+function _prodErrorMap() {
+ return {
+ ["dependent-sdk-initialized-before-auth"]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK."
+ };
+}
+const prodErrorMap = _prodErrorMap;
+const _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory("auth", "Firebase", _prodErrorMap());
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logClient = new Logger("@firebase/auth");
+function _logError(msg, ...args) {
+ if (logClient.logLevel <= LogLevel.ERROR) {
+ logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _fail(authOrCode, ...rest) {
+ throw createErrorInternal(authOrCode, ...rest);
+}
+function _createError(authOrCode, ...rest) {
+ return createErrorInternal(authOrCode, ...rest);
+}
+function _errorWithCustomMessage(auth2, code, message) {
+ const errorMap = Object.assign(Object.assign({}, prodErrorMap()), { [code]: message });
+ const factory = new ErrorFactory("auth", "Firebase", errorMap);
+ return factory.create(code, {
+ appName: auth2.name
+ });
+}
+function _assertInstanceOf(auth2, object, instance) {
+ const constructorInstance = instance;
+ if (!(object instanceof constructorInstance)) {
+ if (constructorInstance.name !== object.constructor.name) {
+ _fail(auth2, "argument-error");
+ }
+ throw _errorWithCustomMessage(auth2, "argument-error", `Type of ${object.constructor.name} does not match expected instance.Did you pass a reference from a different Auth SDK?`);
+ }
+}
+function createErrorInternal(authOrCode, ...rest) {
+ if (typeof authOrCode !== "string") {
+ const code = rest[0];
+ const fullParams = [...rest.slice(1)];
+ if (fullParams[0]) {
+ fullParams[0].appName = authOrCode.name;
+ }
+ return authOrCode._errorFactory.create(code, ...fullParams);
+ }
+ return _DEFAULT_AUTH_ERROR_FACTORY.create(authOrCode, ...rest);
+}
+function _assert(assertion, authOrCode, ...rest) {
+ if (!assertion) {
+ throw createErrorInternal(authOrCode, ...rest);
+ }
+}
+function debugFail(failure) {
+ const message = `INTERNAL ASSERTION FAILED: ` + failure;
+ _logError(message);
+ throw new Error(message);
+}
+function debugAssert(assertion, message) {
+ if (!assertion) {
+ debugFail(message);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const instanceCache = /* @__PURE__ */ new Map();
+function _getInstance(cls) {
+ debugAssert(cls instanceof Function, "Expected a class definition");
+ let instance = instanceCache.get(cls);
+ if (instance) {
+ debugAssert(instance instanceof cls, "Instance stored in cache mismatched with class");
+ return instance;
+ }
+ instance = new cls();
+ instanceCache.set(cls, instance);
+ return instance;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function initializeAuth(app2, deps) {
+ const provider2 = _getProvider(app2, "auth");
+ if (provider2.isInitialized()) {
+ const auth3 = provider2.getImmediate();
+ const initialOptions = provider2.getOptions();
+ if (deepEqual(initialOptions, deps !== null && deps !== void 0 ? deps : {})) {
+ return auth3;
+ } else {
+ _fail(auth3, "already-initialized");
+ }
+ }
+ const auth2 = provider2.initialize({ options: deps });
+ return auth2;
+}
+function _initializeAuthInstance(auth2, deps) {
+ const persistence = (deps === null || deps === void 0 ? void 0 : deps.persistence) || [];
+ const hierarchy = (Array.isArray(persistence) ? persistence : [persistence]).map(_getInstance);
+ if (deps === null || deps === void 0 ? void 0 : deps.errorMap) {
+ auth2._updateErrorMap(deps.errorMap);
+ }
+ auth2._initializeWithPersistence(hierarchy, deps === null || deps === void 0 ? void 0 : deps.popupRedirectResolver);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _getCurrentUrl() {
+ var _a2;
+ return typeof self !== "undefined" && ((_a2 = self.location) === null || _a2 === void 0 ? void 0 : _a2.href) || "";
+}
+function _isHttpOrHttps() {
+ return _getCurrentScheme() === "http:" || _getCurrentScheme() === "https:";
+}
+function _getCurrentScheme() {
+ var _a2;
+ return typeof self !== "undefined" && ((_a2 = self.location) === null || _a2 === void 0 ? void 0 : _a2.protocol) || null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _isOnline() {
+ if (typeof navigator !== "undefined" && navigator && "onLine" in navigator && typeof navigator.onLine === "boolean" && (_isHttpOrHttps() || isBrowserExtension() || "connection" in navigator)) {
+ return navigator.onLine;
+ }
+ return true;
+}
+function _getUserLanguage() {
+ if (typeof navigator === "undefined") {
+ return null;
+ }
+ const navigatorLanguage = navigator;
+ return navigatorLanguage.languages && navigatorLanguage.languages[0] || navigatorLanguage.language || null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Delay {
+ constructor(shortDelay, longDelay) {
+ this.shortDelay = shortDelay;
+ this.longDelay = longDelay;
+ debugAssert(longDelay > shortDelay, "Short delay should be less than long delay!");
+ this.isMobile = isMobileCordova() || isReactNative();
+ }
+ get() {
+ if (!_isOnline()) {
+ return Math.min(5e3, this.shortDelay);
+ }
+ return this.isMobile ? this.longDelay : this.shortDelay;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _emulatorUrl(config, path) {
+ debugAssert(config.emulator, "Emulator should always be set here");
+ const { url } = config.emulator;
+ if (!path) {
+ return url;
+ }
+ return `${url}${path.startsWith("/") ? path.slice(1) : path}`;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FetchProvider {
+ static initialize(fetchImpl, headersImpl, responseImpl) {
+ this.fetchImpl = fetchImpl;
+ if (headersImpl) {
+ this.headersImpl = headersImpl;
+ }
+ if (responseImpl) {
+ this.responseImpl = responseImpl;
+ }
+ }
+ static fetch() {
+ if (this.fetchImpl) {
+ return this.fetchImpl;
+ }
+ if (typeof self !== "undefined" && "fetch" in self) {
+ return self.fetch;
+ }
+ debugFail("Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+ }
+ static headers() {
+ if (this.headersImpl) {
+ return this.headersImpl;
+ }
+ if (typeof self !== "undefined" && "Headers" in self) {
+ return self.Headers;
+ }
+ debugFail("Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+ }
+ static response() {
+ if (this.responseImpl) {
+ return this.responseImpl;
+ }
+ if (typeof self !== "undefined" && "Response" in self) {
+ return self.Response;
+ }
+ debugFail("Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const SERVER_ERROR_MAP = {
+ ["CREDENTIAL_MISMATCH"]: "custom-token-mismatch",
+ ["MISSING_CUSTOM_TOKEN"]: "internal-error",
+ ["INVALID_IDENTIFIER"]: "invalid-email",
+ ["MISSING_CONTINUE_URI"]: "internal-error",
+ ["INVALID_PASSWORD"]: "wrong-password",
+ ["MISSING_PASSWORD"]: "missing-password",
+ ["EMAIL_EXISTS"]: "email-already-in-use",
+ ["PASSWORD_LOGIN_DISABLED"]: "operation-not-allowed",
+ ["INVALID_IDP_RESPONSE"]: "invalid-credential",
+ ["INVALID_PENDING_TOKEN"]: "invalid-credential",
+ ["FEDERATED_USER_ID_ALREADY_LINKED"]: "credential-already-in-use",
+ ["MISSING_REQ_TYPE"]: "internal-error",
+ ["EMAIL_NOT_FOUND"]: "user-not-found",
+ ["RESET_PASSWORD_EXCEED_LIMIT"]: "too-many-requests",
+ ["EXPIRED_OOB_CODE"]: "expired-action-code",
+ ["INVALID_OOB_CODE"]: "invalid-action-code",
+ ["MISSING_OOB_CODE"]: "internal-error",
+ ["CREDENTIAL_TOO_OLD_LOGIN_AGAIN"]: "requires-recent-login",
+ ["INVALID_ID_TOKEN"]: "invalid-user-token",
+ ["TOKEN_EXPIRED"]: "user-token-expired",
+ ["USER_NOT_FOUND"]: "user-token-expired",
+ ["TOO_MANY_ATTEMPTS_TRY_LATER"]: "too-many-requests",
+ ["INVALID_CODE"]: "invalid-verification-code",
+ ["INVALID_SESSION_INFO"]: "invalid-verification-id",
+ ["INVALID_TEMPORARY_PROOF"]: "invalid-credential",
+ ["MISSING_SESSION_INFO"]: "missing-verification-id",
+ ["SESSION_EXPIRED"]: "code-expired",
+ ["MISSING_ANDROID_PACKAGE_NAME"]: "missing-android-pkg-name",
+ ["UNAUTHORIZED_DOMAIN"]: "unauthorized-continue-uri",
+ ["INVALID_OAUTH_CLIENT_ID"]: "invalid-oauth-client-id",
+ ["ADMIN_ONLY_OPERATION"]: "admin-restricted-operation",
+ ["INVALID_MFA_PENDING_CREDENTIAL"]: "invalid-multi-factor-session",
+ ["MFA_ENROLLMENT_NOT_FOUND"]: "multi-factor-info-not-found",
+ ["MISSING_MFA_ENROLLMENT_ID"]: "missing-multi-factor-info",
+ ["MISSING_MFA_PENDING_CREDENTIAL"]: "missing-multi-factor-session",
+ ["SECOND_FACTOR_EXISTS"]: "second-factor-already-in-use",
+ ["SECOND_FACTOR_LIMIT_EXCEEDED"]: "maximum-second-factor-count-exceeded",
+ ["BLOCKING_FUNCTION_ERROR_RESPONSE"]: "internal-error"
+};
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_API_TIMEOUT_MS = new Delay(3e4, 6e4);
+function _addTidIfNecessary(auth2, request) {
+ if (auth2.tenantId && !request.tenantId) {
+ return Object.assign(Object.assign({}, request), { tenantId: auth2.tenantId });
+ }
+ return request;
+}
+async function _performApiRequest(auth2, method, path, request, customErrorMap = {}) {
+ return _performFetchWithErrorHandling(auth2, customErrorMap, async () => {
+ let body = {};
+ let params = {};
+ if (request) {
+ if (method === "GET") {
+ params = request;
+ } else {
+ body = {
+ body: JSON.stringify(request)
+ };
+ }
+ }
+ const query = querystring(Object.assign({ key: auth2.config.apiKey }, params)).slice(1);
+ const headers = await auth2._getAdditionalHeaders();
+ headers["Content-Type"] = "application/json";
+ if (auth2.languageCode) {
+ headers["X-Firebase-Locale"] = auth2.languageCode;
+ }
+ return FetchProvider.fetch()(_getFinalTarget(auth2, auth2.config.apiHost, path, query), Object.assign({
+ method,
+ headers,
+ referrerPolicy: "no-referrer"
+ }, body));
+ });
+}
+async function _performFetchWithErrorHandling(auth2, customErrorMap, fetchFn) {
+ auth2._canInitEmulator = false;
+ const errorMap = Object.assign(Object.assign({}, SERVER_ERROR_MAP), customErrorMap);
+ try {
+ const networkTimeout = new NetworkTimeout(auth2);
+ const response = await Promise.race([
+ fetchFn(),
+ networkTimeout.promise
+ ]);
+ networkTimeout.clearNetworkTimeout();
+ const json = await response.json();
+ if ("needConfirmation" in json) {
+ throw _makeTaggedError(auth2, "account-exists-with-different-credential", json);
+ }
+ if (response.ok && !("errorMessage" in json)) {
+ return json;
+ } else {
+ const errorMessage = response.ok ? json.errorMessage : json.error.message;
+ const [serverErrorCode, serverErrorMessage] = errorMessage.split(" : ");
+ if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED") {
+ throw _makeTaggedError(auth2, "credential-already-in-use", json);
+ } else if (serverErrorCode === "EMAIL_EXISTS") {
+ throw _makeTaggedError(auth2, "email-already-in-use", json);
+ } else if (serverErrorCode === "USER_DISABLED") {
+ throw _makeTaggedError(auth2, "user-disabled", json);
+ }
+ const authError = errorMap[serverErrorCode] || serverErrorCode.toLowerCase().replace(/[_\s]+/g, "-");
+ if (serverErrorMessage) {
+ throw _errorWithCustomMessage(auth2, authError, serverErrorMessage);
+ } else {
+ _fail(auth2, authError);
+ }
+ }
+ } catch (e) {
+ if (e instanceof FirebaseError) {
+ throw e;
+ }
+ _fail(auth2, "network-request-failed", { "message": String(e) });
+ }
+}
+async function _performSignInRequest(auth2, method, path, request, customErrorMap = {}) {
+ const serverResponse = await _performApiRequest(auth2, method, path, request, customErrorMap);
+ if ("mfaPendingCredential" in serverResponse) {
+ _fail(auth2, "multi-factor-auth-required", {
+ _serverResponse: serverResponse
+ });
+ }
+ return serverResponse;
+}
+function _getFinalTarget(auth2, host, path, query) {
+ const base = `${host}${path}?${query}`;
+ if (!auth2.config.emulator) {
+ return `${auth2.config.apiScheme}://${base}`;
+ }
+ return _emulatorUrl(auth2.config, base);
+}
+class NetworkTimeout {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.timer = null;
+ this.promise = new Promise((_, reject) => {
+ this.timer = setTimeout(() => {
+ return reject(_createError(this.auth, "network-request-failed"));
+ }, DEFAULT_API_TIMEOUT_MS.get());
+ });
+ }
+ clearNetworkTimeout() {
+ clearTimeout(this.timer);
+ }
+}
+function _makeTaggedError(auth2, code, response) {
+ const errorParams = {
+ appName: auth2.name
+ };
+ if (response.email) {
+ errorParams.email = response.email;
+ }
+ if (response.phoneNumber) {
+ errorParams.phoneNumber = response.phoneNumber;
+ }
+ const error = _createError(auth2, code, errorParams);
+ error.customData._tokenResponse = response;
+ return error;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function deleteAccount(auth2, request) {
+ return _performApiRequest(auth2, "POST", "/v1/accounts:delete", request);
+}
+async function getAccountInfo(auth2, request) {
+ return _performApiRequest(auth2, "POST", "/v1/accounts:lookup", request);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function utcTimestampToDateString(utcTimestamp) {
+ if (!utcTimestamp) {
+ return void 0;
+ }
+ try {
+ const date = new Date(Number(utcTimestamp));
+ if (!isNaN(date.getTime())) {
+ return date.toUTCString();
+ }
+ } catch (e) {
+ }
+ return void 0;
+}
+async function getIdTokenResult(user, forceRefresh = false) {
+ const userInternal = getModularInstance(user);
+ const token = await userInternal.getIdToken(forceRefresh);
+ const claims = _parseToken(token);
+ _assert(claims && claims.exp && claims.auth_time && claims.iat, userInternal.auth, "internal-error");
+ const firebase = typeof claims.firebase === "object" ? claims.firebase : void 0;
+ const signInProvider = firebase === null || firebase === void 0 ? void 0 : firebase["sign_in_provider"];
+ return {
+ claims,
+ token,
+ authTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.auth_time)),
+ issuedAtTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.iat)),
+ expirationTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.exp)),
+ signInProvider: signInProvider || null,
+ signInSecondFactor: (firebase === null || firebase === void 0 ? void 0 : firebase["sign_in_second_factor"]) || null
+ };
+}
+function secondsStringToMilliseconds(seconds) {
+ return Number(seconds) * 1e3;
+}
+function _parseToken(token) {
+ const [algorithm, payload, signature] = token.split(".");
+ if (algorithm === void 0 || payload === void 0 || signature === void 0) {
+ _logError("JWT malformed, contained fewer than 3 sections");
+ return null;
+ }
+ try {
+ const decoded = base64Decode(payload);
+ if (!decoded) {
+ _logError("Failed to decode base64 JWT payload");
+ return null;
+ }
+ return JSON.parse(decoded);
+ } catch (e) {
+ _logError("Caught error parsing JWT payload as JSON", e === null || e === void 0 ? void 0 : e.toString());
+ return null;
+ }
+}
+function _tokenExpiresIn(token) {
+ const parsedToken = _parseToken(token);
+ _assert(parsedToken, "internal-error");
+ _assert(typeof parsedToken.exp !== "undefined", "internal-error");
+ _assert(typeof parsedToken.iat !== "undefined", "internal-error");
+ return Number(parsedToken.exp) - Number(parsedToken.iat);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _logoutIfInvalidated(user, promise, bypassAuthState = false) {
+ if (bypassAuthState) {
+ return promise;
+ }
+ try {
+ return await promise;
+ } catch (e) {
+ if (e instanceof FirebaseError && isUserInvalidated(e)) {
+ if (user.auth.currentUser === user) {
+ await user.auth.signOut();
+ }
+ }
+ throw e;
+ }
+}
+function isUserInvalidated({ code }) {
+ return code === `auth/${"user-disabled"}` || code === `auth/${"user-token-expired"}`;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ProactiveRefresh {
+ constructor(user) {
+ this.user = user;
+ this.isRunning = false;
+ this.timerId = null;
+ this.errorBackoff = 3e4;
+ }
+ _start() {
+ if (this.isRunning) {
+ return;
+ }
+ this.isRunning = true;
+ this.schedule();
+ }
+ _stop() {
+ if (!this.isRunning) {
+ return;
+ }
+ this.isRunning = false;
+ if (this.timerId !== null) {
+ clearTimeout(this.timerId);
+ }
+ }
+ getInterval(wasError) {
+ var _a2;
+ if (wasError) {
+ const interval = this.errorBackoff;
+ this.errorBackoff = Math.min(this.errorBackoff * 2, 96e4);
+ return interval;
+ } else {
+ this.errorBackoff = 3e4;
+ const expTime = (_a2 = this.user.stsTokenManager.expirationTime) !== null && _a2 !== void 0 ? _a2 : 0;
+ const interval = expTime - Date.now() - 3e5;
+ return Math.max(0, interval);
+ }
+ }
+ schedule(wasError = false) {
+ if (!this.isRunning) {
+ return;
+ }
+ const interval = this.getInterval(wasError);
+ this.timerId = setTimeout(async () => {
+ await this.iteration();
+ }, interval);
+ }
+ async iteration() {
+ try {
+ await this.user.getIdToken(true);
+ } catch (e) {
+ if ((e === null || e === void 0 ? void 0 : e.code) === `auth/${"network-request-failed"}`) {
+ this.schedule(true);
+ }
+ return;
+ }
+ this.schedule();
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UserMetadata {
+ constructor(createdAt, lastLoginAt) {
+ this.createdAt = createdAt;
+ this.lastLoginAt = lastLoginAt;
+ this._initializeTime();
+ }
+ _initializeTime() {
+ this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);
+ this.creationTime = utcTimestampToDateString(this.createdAt);
+ }
+ _copy(metadata) {
+ this.createdAt = metadata.createdAt;
+ this.lastLoginAt = metadata.lastLoginAt;
+ this._initializeTime();
+ }
+ toJSON() {
+ return {
+ createdAt: this.createdAt,
+ lastLoginAt: this.lastLoginAt
+ };
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _reloadWithoutSaving(user) {
+ var _a2;
+ const auth2 = user.auth;
+ const idToken = await user.getIdToken();
+ const response = await _logoutIfInvalidated(user, getAccountInfo(auth2, { idToken }));
+ _assert(response === null || response === void 0 ? void 0 : response.users.length, auth2, "internal-error");
+ const coreAccount = response.users[0];
+ user._notifyReloadListener(coreAccount);
+ const newProviderData = ((_a2 = coreAccount.providerUserInfo) === null || _a2 === void 0 ? void 0 : _a2.length) ? extractProviderData(coreAccount.providerUserInfo) : [];
+ const providerData = mergeProviderData(user.providerData, newProviderData);
+ const oldIsAnonymous = user.isAnonymous;
+ const newIsAnonymous = !(user.email && coreAccount.passwordHash) && !(providerData === null || providerData === void 0 ? void 0 : providerData.length);
+ const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;
+ const updates = {
+ uid: coreAccount.localId,
+ displayName: coreAccount.displayName || null,
+ photoURL: coreAccount.photoUrl || null,
+ email: coreAccount.email || null,
+ emailVerified: coreAccount.emailVerified || false,
+ phoneNumber: coreAccount.phoneNumber || null,
+ tenantId: coreAccount.tenantId || null,
+ providerData,
+ metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),
+ isAnonymous
+ };
+ Object.assign(user, updates);
+}
+async function reload(user) {
+ const userInternal = getModularInstance(user);
+ await _reloadWithoutSaving(userInternal);
+ await userInternal.auth._persistUserIfCurrent(userInternal);
+ userInternal.auth._notifyListenersIfCurrent(userInternal);
+}
+function mergeProviderData(original, newData) {
+ const deduped = original.filter((o) => !newData.some((n) => n.providerId === o.providerId));
+ return [...deduped, ...newData];
+}
+function extractProviderData(providers) {
+ return providers.map((_a2) => {
+ var { providerId } = _a2, provider2 = __rest(_a2, ["providerId"]);
+ return {
+ providerId,
+ uid: provider2.rawId || "",
+ displayName: provider2.displayName || null,
+ email: provider2.email || null,
+ phoneNumber: provider2.phoneNumber || null,
+ photoURL: provider2.photoUrl || null
+ };
+ });
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function requestStsToken(auth2, refreshToken) {
+ const response = await _performFetchWithErrorHandling(auth2, {}, async () => {
+ const body = querystring({
+ "grant_type": "refresh_token",
+ "refresh_token": refreshToken
+ }).slice(1);
+ const { tokenApiHost, apiKey } = auth2.config;
+ const url = _getFinalTarget(auth2, tokenApiHost, "/v1/token", `key=${apiKey}`);
+ const headers = await auth2._getAdditionalHeaders();
+ headers["Content-Type"] = "application/x-www-form-urlencoded";
+ return FetchProvider.fetch()(url, {
+ method: "POST",
+ headers,
+ body
+ });
+ });
+ return {
+ accessToken: response.access_token,
+ expiresIn: response.expires_in,
+ refreshToken: response.refresh_token
+ };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class StsTokenManager {
+ constructor() {
+ this.refreshToken = null;
+ this.accessToken = null;
+ this.expirationTime = null;
+ }
+ get isExpired() {
+ return !this.expirationTime || Date.now() > this.expirationTime - 3e4;
+ }
+ updateFromServerResponse(response) {
+ _assert(response.idToken, "internal-error");
+ _assert(typeof response.idToken !== "undefined", "internal-error");
+ _assert(typeof response.refreshToken !== "undefined", "internal-error");
+ const expiresIn = "expiresIn" in response && typeof response.expiresIn !== "undefined" ? Number(response.expiresIn) : _tokenExpiresIn(response.idToken);
+ this.updateTokensAndExpiration(response.idToken, response.refreshToken, expiresIn);
+ }
+ async getToken(auth2, forceRefresh = false) {
+ _assert(!this.accessToken || this.refreshToken, auth2, "user-token-expired");
+ if (!forceRefresh && this.accessToken && !this.isExpired) {
+ return this.accessToken;
+ }
+ if (this.refreshToken) {
+ await this.refresh(auth2, this.refreshToken);
+ return this.accessToken;
+ }
+ return null;
+ }
+ clearRefreshToken() {
+ this.refreshToken = null;
+ }
+ async refresh(auth2, oldToken) {
+ const { accessToken, refreshToken, expiresIn } = await requestStsToken(auth2, oldToken);
+ this.updateTokensAndExpiration(accessToken, refreshToken, Number(expiresIn));
+ }
+ updateTokensAndExpiration(accessToken, refreshToken, expiresInSec) {
+ this.refreshToken = refreshToken || null;
+ this.accessToken = accessToken || null;
+ this.expirationTime = Date.now() + expiresInSec * 1e3;
+ }
+ static fromJSON(appName, object) {
+ const { refreshToken, accessToken, expirationTime } = object;
+ const manager = new StsTokenManager();
+ if (refreshToken) {
+ _assert(typeof refreshToken === "string", "internal-error", {
+ appName
+ });
+ manager.refreshToken = refreshToken;
+ }
+ if (accessToken) {
+ _assert(typeof accessToken === "string", "internal-error", {
+ appName
+ });
+ manager.accessToken = accessToken;
+ }
+ if (expirationTime) {
+ _assert(typeof expirationTime === "number", "internal-error", {
+ appName
+ });
+ manager.expirationTime = expirationTime;
+ }
+ return manager;
+ }
+ toJSON() {
+ return {
+ refreshToken: this.refreshToken,
+ accessToken: this.accessToken,
+ expirationTime: this.expirationTime
+ };
+ }
+ _assign(stsTokenManager) {
+ this.accessToken = stsTokenManager.accessToken;
+ this.refreshToken = stsTokenManager.refreshToken;
+ this.expirationTime = stsTokenManager.expirationTime;
+ }
+ _clone() {
+ return Object.assign(new StsTokenManager(), this.toJSON());
+ }
+ _performRefresh() {
+ return debugFail("not implemented");
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function assertStringOrUndefined(assertion, appName) {
+ _assert(typeof assertion === "string" || typeof assertion === "undefined", "internal-error", { appName });
+}
+class UserImpl {
+ constructor(_a2) {
+ var { uid, auth: auth2, stsTokenManager } = _a2, opt = __rest(_a2, ["uid", "auth", "stsTokenManager"]);
+ this.providerId = "firebase";
+ this.proactiveRefresh = new ProactiveRefresh(this);
+ this.reloadUserInfo = null;
+ this.reloadListener = null;
+ this.uid = uid;
+ this.auth = auth2;
+ this.stsTokenManager = stsTokenManager;
+ this.accessToken = stsTokenManager.accessToken;
+ this.displayName = opt.displayName || null;
+ this.email = opt.email || null;
+ this.emailVerified = opt.emailVerified || false;
+ this.phoneNumber = opt.phoneNumber || null;
+ this.photoURL = opt.photoURL || null;
+ this.isAnonymous = opt.isAnonymous || false;
+ this.tenantId = opt.tenantId || null;
+ this.providerData = opt.providerData ? [...opt.providerData] : [];
+ this.metadata = new UserMetadata(opt.createdAt || void 0, opt.lastLoginAt || void 0);
+ }
+ async getIdToken(forceRefresh) {
+ const accessToken = await _logoutIfInvalidated(this, this.stsTokenManager.getToken(this.auth, forceRefresh));
+ _assert(accessToken, this.auth, "internal-error");
+ if (this.accessToken !== accessToken) {
+ this.accessToken = accessToken;
+ await this.auth._persistUserIfCurrent(this);
+ this.auth._notifyListenersIfCurrent(this);
+ }
+ return accessToken;
+ }
+ getIdTokenResult(forceRefresh) {
+ return getIdTokenResult(this, forceRefresh);
+ }
+ reload() {
+ return reload(this);
+ }
+ _assign(user) {
+ if (this === user) {
+ return;
+ }
+ _assert(this.uid === user.uid, this.auth, "internal-error");
+ this.displayName = user.displayName;
+ this.photoURL = user.photoURL;
+ this.email = user.email;
+ this.emailVerified = user.emailVerified;
+ this.phoneNumber = user.phoneNumber;
+ this.isAnonymous = user.isAnonymous;
+ this.tenantId = user.tenantId;
+ this.providerData = user.providerData.map((userInfo) => Object.assign({}, userInfo));
+ this.metadata._copy(user.metadata);
+ this.stsTokenManager._assign(user.stsTokenManager);
+ }
+ _clone(auth2) {
+ const newUser = new UserImpl(Object.assign(Object.assign({}, this), { auth: auth2, stsTokenManager: this.stsTokenManager._clone() }));
+ newUser.metadata._copy(this.metadata);
+ return newUser;
+ }
+ _onReload(callback) {
+ _assert(!this.reloadListener, this.auth, "internal-error");
+ this.reloadListener = callback;
+ if (this.reloadUserInfo) {
+ this._notifyReloadListener(this.reloadUserInfo);
+ this.reloadUserInfo = null;
+ }
+ }
+ _notifyReloadListener(userInfo) {
+ if (this.reloadListener) {
+ this.reloadListener(userInfo);
+ } else {
+ this.reloadUserInfo = userInfo;
+ }
+ }
+ _startProactiveRefresh() {
+ this.proactiveRefresh._start();
+ }
+ _stopProactiveRefresh() {
+ this.proactiveRefresh._stop();
+ }
+ async _updateTokensIfNecessary(response, reload2 = false) {
+ let tokensRefreshed = false;
+ if (response.idToken && response.idToken !== this.stsTokenManager.accessToken) {
+ this.stsTokenManager.updateFromServerResponse(response);
+ tokensRefreshed = true;
+ }
+ if (reload2) {
+ await _reloadWithoutSaving(this);
+ }
+ await this.auth._persistUserIfCurrent(this);
+ if (tokensRefreshed) {
+ this.auth._notifyListenersIfCurrent(this);
+ }
+ }
+ async delete() {
+ const idToken = await this.getIdToken();
+ await _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken }));
+ this.stsTokenManager.clearRefreshToken();
+ return this.auth.signOut();
+ }
+ toJSON() {
+ return Object.assign(Object.assign({
+ uid: this.uid,
+ email: this.email || void 0,
+ emailVerified: this.emailVerified,
+ displayName: this.displayName || void 0,
+ isAnonymous: this.isAnonymous,
+ photoURL: this.photoURL || void 0,
+ phoneNumber: this.phoneNumber || void 0,
+ tenantId: this.tenantId || void 0,
+ providerData: this.providerData.map((userInfo) => Object.assign({}, userInfo)),
+ stsTokenManager: this.stsTokenManager.toJSON(),
+ _redirectEventId: this._redirectEventId
+ }, this.metadata.toJSON()), {
+ apiKey: this.auth.config.apiKey,
+ appName: this.auth.name
+ });
+ }
+ get refreshToken() {
+ return this.stsTokenManager.refreshToken || "";
+ }
+ static _fromJSON(auth2, object) {
+ var _a2, _b, _c2, _d, _e2, _f, _g, _h2;
+ const displayName = (_a2 = object.displayName) !== null && _a2 !== void 0 ? _a2 : void 0;
+ const email = (_b = object.email) !== null && _b !== void 0 ? _b : void 0;
+ const phoneNumber = (_c2 = object.phoneNumber) !== null && _c2 !== void 0 ? _c2 : void 0;
+ const photoURL = (_d = object.photoURL) !== null && _d !== void 0 ? _d : void 0;
+ const tenantId = (_e2 = object.tenantId) !== null && _e2 !== void 0 ? _e2 : void 0;
+ const _redirectEventId = (_f = object._redirectEventId) !== null && _f !== void 0 ? _f : void 0;
+ const createdAt = (_g = object.createdAt) !== null && _g !== void 0 ? _g : void 0;
+ const lastLoginAt = (_h2 = object.lastLoginAt) !== null && _h2 !== void 0 ? _h2 : void 0;
+ const { uid, emailVerified, isAnonymous, providerData, stsTokenManager: plainObjectTokenManager } = object;
+ _assert(uid && plainObjectTokenManager, auth2, "internal-error");
+ const stsTokenManager = StsTokenManager.fromJSON(this.name, plainObjectTokenManager);
+ _assert(typeof uid === "string", auth2, "internal-error");
+ assertStringOrUndefined(displayName, auth2.name);
+ assertStringOrUndefined(email, auth2.name);
+ _assert(typeof emailVerified === "boolean", auth2, "internal-error");
+ _assert(typeof isAnonymous === "boolean", auth2, "internal-error");
+ assertStringOrUndefined(phoneNumber, auth2.name);
+ assertStringOrUndefined(photoURL, auth2.name);
+ assertStringOrUndefined(tenantId, auth2.name);
+ assertStringOrUndefined(_redirectEventId, auth2.name);
+ assertStringOrUndefined(createdAt, auth2.name);
+ assertStringOrUndefined(lastLoginAt, auth2.name);
+ const user = new UserImpl({
+ uid,
+ auth: auth2,
+ email,
+ emailVerified,
+ displayName,
+ isAnonymous,
+ photoURL,
+ phoneNumber,
+ tenantId,
+ stsTokenManager,
+ createdAt,
+ lastLoginAt
+ });
+ if (providerData && Array.isArray(providerData)) {
+ user.providerData = providerData.map((userInfo) => Object.assign({}, userInfo));
+ }
+ if (_redirectEventId) {
+ user._redirectEventId = _redirectEventId;
+ }
+ return user;
+ }
+ static async _fromIdTokenResponse(auth2, idTokenResponse, isAnonymous = false) {
+ const stsTokenManager = new StsTokenManager();
+ stsTokenManager.updateFromServerResponse(idTokenResponse);
+ const user = new UserImpl({
+ uid: idTokenResponse.localId,
+ auth: auth2,
+ stsTokenManager,
+ isAnonymous
+ });
+ await _reloadWithoutSaving(user);
+ return user;
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class InMemoryPersistence {
+ constructor() {
+ this.type = "NONE";
+ this.storage = {};
+ }
+ async _isAvailable() {
+ return true;
+ }
+ async _set(key, value) {
+ this.storage[key] = value;
+ }
+ async _get(key) {
+ const value = this.storage[key];
+ return value === void 0 ? null : value;
+ }
+ async _remove(key) {
+ delete this.storage[key];
+ }
+ _addListener(_key, _listener) {
+ return;
+ }
+ _removeListener(_key, _listener) {
+ return;
+ }
+}
+InMemoryPersistence.type = "NONE";
+const inMemoryPersistence = InMemoryPersistence;
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _persistenceKeyName(key, apiKey, appName) {
+ return `${"firebase"}:${key}:${apiKey}:${appName}`;
+}
+class PersistenceUserManager {
+ constructor(persistence, auth2, userKey) {
+ this.persistence = persistence;
+ this.auth = auth2;
+ this.userKey = userKey;
+ const { config, name: name2 } = this.auth;
+ this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name2);
+ this.fullPersistenceKey = _persistenceKeyName("persistence", config.apiKey, name2);
+ this.boundEventHandler = auth2._onStorageEvent.bind(auth2);
+ this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
+ }
+ setCurrentUser(user) {
+ return this.persistence._set(this.fullUserKey, user.toJSON());
+ }
+ async getCurrentUser() {
+ const blob = await this.persistence._get(this.fullUserKey);
+ return blob ? UserImpl._fromJSON(this.auth, blob) : null;
+ }
+ removeCurrentUser() {
+ return this.persistence._remove(this.fullUserKey);
+ }
+ savePersistenceForRedirect() {
+ return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
+ }
+ async setPersistence(newPersistence) {
+ if (this.persistence === newPersistence) {
+ return;
+ }
+ const currentUser = await this.getCurrentUser();
+ await this.removeCurrentUser();
+ this.persistence = newPersistence;
+ if (currentUser) {
+ return this.setCurrentUser(currentUser);
+ }
+ }
+ delete() {
+ this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
+ }
+ static async create(auth2, persistenceHierarchy, userKey = "authUser") {
+ if (!persistenceHierarchy.length) {
+ return new PersistenceUserManager(_getInstance(inMemoryPersistence), auth2, userKey);
+ }
+ const availablePersistences = (await Promise.all(persistenceHierarchy.map(async (persistence) => {
+ if (await persistence._isAvailable()) {
+ return persistence;
+ }
+ return void 0;
+ }))).filter((persistence) => persistence);
+ let selectedPersistence = availablePersistences[0] || _getInstance(inMemoryPersistence);
+ const key = _persistenceKeyName(userKey, auth2.config.apiKey, auth2.name);
+ let userToMigrate = null;
+ for (const persistence of persistenceHierarchy) {
+ try {
+ const blob = await persistence._get(key);
+ if (blob) {
+ const user = UserImpl._fromJSON(auth2, blob);
+ if (persistence !== selectedPersistence) {
+ userToMigrate = user;
+ }
+ selectedPersistence = persistence;
+ break;
+ }
+ } catch (_a2) {
+ }
+ }
+ const migrationHierarchy = availablePersistences.filter((p2) => p2._shouldAllowMigration);
+ if (!selectedPersistence._shouldAllowMigration || !migrationHierarchy.length) {
+ return new PersistenceUserManager(selectedPersistence, auth2, userKey);
+ }
+ selectedPersistence = migrationHierarchy[0];
+ if (userToMigrate) {
+ await selectedPersistence._set(key, userToMigrate.toJSON());
+ }
+ await Promise.all(persistenceHierarchy.map(async (persistence) => {
+ if (persistence !== selectedPersistence) {
+ try {
+ await persistence._remove(key);
+ } catch (_a2) {
+ }
+ }
+ }));
+ return new PersistenceUserManager(selectedPersistence, auth2, userKey);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _getBrowserName(userAgent) {
+ const ua2 = userAgent.toLowerCase();
+ if (ua2.includes("opera/") || ua2.includes("opr/") || ua2.includes("opios/")) {
+ return "Opera";
+ } else if (_isIEMobile(ua2)) {
+ return "IEMobile";
+ } else if (ua2.includes("msie") || ua2.includes("trident/")) {
+ return "IE";
+ } else if (ua2.includes("edge/")) {
+ return "Edge";
+ } else if (_isFirefox(ua2)) {
+ return "Firefox";
+ } else if (ua2.includes("silk/")) {
+ return "Silk";
+ } else if (_isBlackBerry(ua2)) {
+ return "Blackberry";
+ } else if (_isWebOS(ua2)) {
+ return "Webos";
+ } else if (_isSafari(ua2)) {
+ return "Safari";
+ } else if ((ua2.includes("chrome/") || _isChromeIOS(ua2)) && !ua2.includes("edge/")) {
+ return "Chrome";
+ } else if (_isAndroid(ua2)) {
+ return "Android";
+ } else {
+ const re = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/;
+ const matches = userAgent.match(re);
+ if ((matches === null || matches === void 0 ? void 0 : matches.length) === 2) {
+ return matches[1];
+ }
+ }
+ return "Other";
+}
+function _isFirefox(ua2 = getUA()) {
+ return /firefox\//i.test(ua2);
+}
+function _isSafari(userAgent = getUA()) {
+ const ua2 = userAgent.toLowerCase();
+ return ua2.includes("safari/") && !ua2.includes("chrome/") && !ua2.includes("crios/") && !ua2.includes("android");
+}
+function _isChromeIOS(ua2 = getUA()) {
+ return /crios\//i.test(ua2);
+}
+function _isIEMobile(ua2 = getUA()) {
+ return /iemobile/i.test(ua2);
+}
+function _isAndroid(ua2 = getUA()) {
+ return /android/i.test(ua2);
+}
+function _isBlackBerry(ua2 = getUA()) {
+ return /blackberry/i.test(ua2);
+}
+function _isWebOS(ua2 = getUA()) {
+ return /webos/i.test(ua2);
+}
+function _isIOS(ua2 = getUA()) {
+ return /iphone|ipad|ipod/i.test(ua2) || /macintosh/i.test(ua2) && /mobile/i.test(ua2);
+}
+function _isIOSStandalone(ua2 = getUA()) {
+ var _a2;
+ return _isIOS(ua2) && !!((_a2 = window.navigator) === null || _a2 === void 0 ? void 0 : _a2.standalone);
+}
+function _isIE10() {
+ return isIE() && document.documentMode === 10;
+}
+function _isMobileBrowser(ua2 = getUA()) {
+ return _isIOS(ua2) || _isAndroid(ua2) || _isWebOS(ua2) || _isBlackBerry(ua2) || /windows phone/i.test(ua2) || _isIEMobile(ua2);
+}
+function _isIframe() {
+ try {
+ return !!(window && window !== window.top);
+ } catch (e) {
+ return false;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _getClientVersion(clientPlatform, frameworks = []) {
+ let reportedPlatform;
+ switch (clientPlatform) {
+ case "Browser":
+ reportedPlatform = _getBrowserName(getUA());
+ break;
+ case "Worker":
+ reportedPlatform = `${_getBrowserName(getUA())}-${clientPlatform}`;
+ break;
+ default:
+ reportedPlatform = clientPlatform;
+ }
+ const reportedFrameworks = frameworks.length ? frameworks.join(",") : "FirebaseCore-web";
+ return `${reportedPlatform}/${"JsCore"}/${SDK_VERSION}/${reportedFrameworks}`;
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthMiddlewareQueue {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.queue = [];
+ }
+ pushCallback(callback, onAbort) {
+ const wrappedCallback = (user) => new Promise((resolve, reject) => {
+ try {
+ const result = callback(user);
+ resolve(result);
+ } catch (e) {
+ reject(e);
+ }
+ });
+ wrappedCallback.onAbort = onAbort;
+ this.queue.push(wrappedCallback);
+ const index = this.queue.length - 1;
+ return () => {
+ this.queue[index] = () => Promise.resolve();
+ };
+ }
+ async runMiddleware(nextUser) {
+ if (this.auth.currentUser === nextUser) {
+ return;
+ }
+ const onAbortStack = [];
+ try {
+ for (const beforeStateCallback of this.queue) {
+ await beforeStateCallback(nextUser);
+ if (beforeStateCallback.onAbort) {
+ onAbortStack.push(beforeStateCallback.onAbort);
+ }
+ }
+ } catch (e) {
+ onAbortStack.reverse();
+ for (const onAbort of onAbortStack) {
+ try {
+ onAbort();
+ } catch (_) {
+ }
+ }
+ throw this.auth._errorFactory.create("login-blocked", {
+ originalMessage: e === null || e === void 0 ? void 0 : e.message
+ });
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthImpl {
+ constructor(app2, heartbeatServiceProvider, config) {
+ this.app = app2;
+ this.heartbeatServiceProvider = heartbeatServiceProvider;
+ this.config = config;
+ this.currentUser = null;
+ this.emulatorConfig = null;
+ this.operations = Promise.resolve();
+ this.authStateSubscription = new Subscription(this);
+ this.idTokenSubscription = new Subscription(this);
+ this.beforeStateQueue = new AuthMiddlewareQueue(this);
+ this.redirectUser = null;
+ this.isProactiveRefreshEnabled = false;
+ this._canInitEmulator = true;
+ this._isInitialized = false;
+ this._deleted = false;
+ this._initializationPromise = null;
+ this._popupRedirectResolver = null;
+ this._errorFactory = _DEFAULT_AUTH_ERROR_FACTORY;
+ this.lastNotifiedUid = void 0;
+ this.languageCode = null;
+ this.tenantId = null;
+ this.settings = { appVerificationDisabledForTesting: false };
+ this.frameworks = [];
+ this.name = app2.name;
+ this.clientVersion = config.sdkClientVersion;
+ }
+ _initializeWithPersistence(persistenceHierarchy, popupRedirectResolver) {
+ if (popupRedirectResolver) {
+ this._popupRedirectResolver = _getInstance(popupRedirectResolver);
+ }
+ this._initializationPromise = this.queue(async () => {
+ var _a2, _b;
+ if (this._deleted) {
+ return;
+ }
+ this.persistenceManager = await PersistenceUserManager.create(this, persistenceHierarchy);
+ if (this._deleted) {
+ return;
+ }
+ if ((_a2 = this._popupRedirectResolver) === null || _a2 === void 0 ? void 0 : _a2._shouldInitProactively) {
+ try {
+ await this._popupRedirectResolver._initialize(this);
+ } catch (e) {
+ }
+ }
+ await this.initializeCurrentUser(popupRedirectResolver);
+ this.lastNotifiedUid = ((_b = this.currentUser) === null || _b === void 0 ? void 0 : _b.uid) || null;
+ if (this._deleted) {
+ return;
+ }
+ this._isInitialized = true;
+ });
+ return this._initializationPromise;
+ }
+ async _onStorageEvent() {
+ if (this._deleted) {
+ return;
+ }
+ const user = await this.assertedPersistence.getCurrentUser();
+ if (!this.currentUser && !user) {
+ return;
+ }
+ if (this.currentUser && user && this.currentUser.uid === user.uid) {
+ this._currentUser._assign(user);
+ await this.currentUser.getIdToken();
+ return;
+ }
+ await this._updateCurrentUser(user, true);
+ }
+ async initializeCurrentUser(popupRedirectResolver) {
+ var _a2;
+ const previouslyStoredUser = await this.assertedPersistence.getCurrentUser();
+ let futureCurrentUser = previouslyStoredUser;
+ let needsTocheckMiddleware = false;
+ if (popupRedirectResolver && this.config.authDomain) {
+ await this.getOrInitRedirectPersistenceManager();
+ const redirectUserEventId = (_a2 = this.redirectUser) === null || _a2 === void 0 ? void 0 : _a2._redirectEventId;
+ const storedUserEventId = futureCurrentUser === null || futureCurrentUser === void 0 ? void 0 : futureCurrentUser._redirectEventId;
+ const result = await this.tryRedirectSignIn(popupRedirectResolver);
+ if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) && (result === null || result === void 0 ? void 0 : result.user)) {
+ futureCurrentUser = result.user;
+ needsTocheckMiddleware = true;
+ }
+ }
+ if (!futureCurrentUser) {
+ return this.directlySetCurrentUser(null);
+ }
+ if (!futureCurrentUser._redirectEventId) {
+ if (needsTocheckMiddleware) {
+ try {
+ await this.beforeStateQueue.runMiddleware(futureCurrentUser);
+ } catch (e) {
+ futureCurrentUser = previouslyStoredUser;
+ this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(e));
+ }
+ }
+ if (futureCurrentUser) {
+ return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
+ } else {
+ return this.directlySetCurrentUser(null);
+ }
+ }
+ _assert(this._popupRedirectResolver, this, "argument-error");
+ await this.getOrInitRedirectPersistenceManager();
+ if (this.redirectUser && this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
+ return this.directlySetCurrentUser(futureCurrentUser);
+ }
+ return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
+ }
+ async tryRedirectSignIn(redirectResolver) {
+ let result = null;
+ try {
+ result = await this._popupRedirectResolver._completeRedirectFn(this, redirectResolver, true);
+ } catch (e) {
+ await this._setRedirectUser(null);
+ }
+ return result;
+ }
+ async reloadAndSetCurrentUserOrClear(user) {
+ try {
+ await _reloadWithoutSaving(user);
+ } catch (e) {
+ if ((e === null || e === void 0 ? void 0 : e.code) !== `auth/${"network-request-failed"}`) {
+ return this.directlySetCurrentUser(null);
+ }
+ }
+ return this.directlySetCurrentUser(user);
+ }
+ useDeviceLanguage() {
+ this.languageCode = _getUserLanguage();
+ }
+ async _delete() {
+ this._deleted = true;
+ }
+ async updateCurrentUser(userExtern) {
+ const user = userExtern ? getModularInstance(userExtern) : null;
+ if (user) {
+ _assert(user.auth.config.apiKey === this.config.apiKey, this, "invalid-user-token");
+ }
+ return this._updateCurrentUser(user && user._clone(this));
+ }
+ async _updateCurrentUser(user, skipBeforeStateCallbacks = false) {
+ if (this._deleted) {
+ return;
+ }
+ if (user) {
+ _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch");
+ }
+ if (!skipBeforeStateCallbacks) {
+ await this.beforeStateQueue.runMiddleware(user);
+ }
+ return this.queue(async () => {
+ await this.directlySetCurrentUser(user);
+ this.notifyAuthListeners();
+ });
+ }
+ async signOut() {
+ await this.beforeStateQueue.runMiddleware(null);
+ if (this.redirectPersistenceManager || this._popupRedirectResolver) {
+ await this._setRedirectUser(null);
+ }
+ return this._updateCurrentUser(null, true);
+ }
+ setPersistence(persistence) {
+ return this.queue(async () => {
+ await this.assertedPersistence.setPersistence(_getInstance(persistence));
+ });
+ }
+ _getPersistence() {
+ return this.assertedPersistence.persistence.type;
+ }
+ _updateErrorMap(errorMap) {
+ this._errorFactory = new ErrorFactory("auth", "Firebase", errorMap());
+ }
+ onAuthStateChanged(nextOrObserver, error, completed) {
+ return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
+ }
+ beforeAuthStateChanged(callback, onAbort) {
+ return this.beforeStateQueue.pushCallback(callback, onAbort);
+ }
+ onIdTokenChanged(nextOrObserver, error, completed) {
+ return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
+ }
+ toJSON() {
+ var _a2;
+ return {
+ apiKey: this.config.apiKey,
+ authDomain: this.config.authDomain,
+ appName: this.name,
+ currentUser: (_a2 = this._currentUser) === null || _a2 === void 0 ? void 0 : _a2.toJSON()
+ };
+ }
+ async _setRedirectUser(user, popupRedirectResolver) {
+ const redirectManager = await this.getOrInitRedirectPersistenceManager(popupRedirectResolver);
+ return user === null ? redirectManager.removeCurrentUser() : redirectManager.setCurrentUser(user);
+ }
+ async getOrInitRedirectPersistenceManager(popupRedirectResolver) {
+ if (!this.redirectPersistenceManager) {
+ const resolver = popupRedirectResolver && _getInstance(popupRedirectResolver) || this._popupRedirectResolver;
+ _assert(resolver, this, "argument-error");
+ this.redirectPersistenceManager = await PersistenceUserManager.create(this, [_getInstance(resolver._redirectPersistence)], "redirectUser");
+ this.redirectUser = await this.redirectPersistenceManager.getCurrentUser();
+ }
+ return this.redirectPersistenceManager;
+ }
+ async _redirectUserForId(id2) {
+ var _a2, _b;
+ if (this._isInitialized) {
+ await this.queue(async () => {
+ });
+ }
+ if (((_a2 = this._currentUser) === null || _a2 === void 0 ? void 0 : _a2._redirectEventId) === id2) {
+ return this._currentUser;
+ }
+ if (((_b = this.redirectUser) === null || _b === void 0 ? void 0 : _b._redirectEventId) === id2) {
+ return this.redirectUser;
+ }
+ return null;
+ }
+ async _persistUserIfCurrent(user) {
+ if (user === this.currentUser) {
+ return this.queue(async () => this.directlySetCurrentUser(user));
+ }
+ }
+ _notifyListenersIfCurrent(user) {
+ if (user === this.currentUser) {
+ this.notifyAuthListeners();
+ }
+ }
+ _key() {
+ return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;
+ }
+ _startProactiveRefresh() {
+ this.isProactiveRefreshEnabled = true;
+ if (this.currentUser) {
+ this._currentUser._startProactiveRefresh();
+ }
+ }
+ _stopProactiveRefresh() {
+ this.isProactiveRefreshEnabled = false;
+ if (this.currentUser) {
+ this._currentUser._stopProactiveRefresh();
+ }
+ }
+ get _currentUser() {
+ return this.currentUser;
+ }
+ notifyAuthListeners() {
+ var _a2, _b;
+ if (!this._isInitialized) {
+ return;
+ }
+ this.idTokenSubscription.next(this.currentUser);
+ const currentUid = (_b = (_a2 = this.currentUser) === null || _a2 === void 0 ? void 0 : _a2.uid) !== null && _b !== void 0 ? _b : null;
+ if (this.lastNotifiedUid !== currentUid) {
+ this.lastNotifiedUid = currentUid;
+ this.authStateSubscription.next(this.currentUser);
+ }
+ }
+ registerStateListener(subscription, nextOrObserver, error, completed) {
+ if (this._deleted) {
+ return () => {
+ };
+ }
+ const cb2 = typeof nextOrObserver === "function" ? nextOrObserver : nextOrObserver.next.bind(nextOrObserver);
+ const promise = this._isInitialized ? Promise.resolve() : this._initializationPromise;
+ _assert(promise, this, "internal-error");
+ promise.then(() => cb2(this.currentUser));
+ if (typeof nextOrObserver === "function") {
+ return subscription.addObserver(nextOrObserver, error, completed);
+ } else {
+ return subscription.addObserver(nextOrObserver);
+ }
+ }
+ async directlySetCurrentUser(user) {
+ if (this.currentUser && this.currentUser !== user) {
+ this._currentUser._stopProactiveRefresh();
+ }
+ if (user && this.isProactiveRefreshEnabled) {
+ user._startProactiveRefresh();
+ }
+ this.currentUser = user;
+ if (user) {
+ await this.assertedPersistence.setCurrentUser(user);
+ } else {
+ await this.assertedPersistence.removeCurrentUser();
+ }
+ }
+ queue(action) {
+ this.operations = this.operations.then(action, action);
+ return this.operations;
+ }
+ get assertedPersistence() {
+ _assert(this.persistenceManager, this, "internal-error");
+ return this.persistenceManager;
+ }
+ _logFramework(framework) {
+ if (!framework || this.frameworks.includes(framework)) {
+ return;
+ }
+ this.frameworks.push(framework);
+ this.frameworks.sort();
+ this.clientVersion = _getClientVersion(this.config.clientPlatform, this._getFrameworks());
+ }
+ _getFrameworks() {
+ return this.frameworks;
+ }
+ async _getAdditionalHeaders() {
+ var _a2;
+ const headers = {
+ ["X-Client-Version"]: this.clientVersion
+ };
+ if (this.app.options.appId) {
+ headers["X-Firebase-gmpid"] = this.app.options.appId;
+ }
+ const heartbeatsHeader = await ((_a2 = this.heartbeatServiceProvider.getImmediate({
+ optional: true
+ })) === null || _a2 === void 0 ? void 0 : _a2.getHeartbeatsHeader());
+ if (heartbeatsHeader) {
+ headers["X-Firebase-Client"] = heartbeatsHeader;
+ }
+ return headers;
+ }
+}
+function _castAuth(auth2) {
+ return getModularInstance(auth2);
+}
+class Subscription {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.observer = null;
+ this.addObserver = createSubscribe((observer) => this.observer = observer);
+ }
+ get next() {
+ _assert(this.observer, this.auth, "internal-error");
+ return this.observer.next.bind(this.observer);
+ }
+}
+function connectAuthEmulator(auth2, url, options) {
+ const authInternal = _castAuth(auth2);
+ _assert(authInternal._canInitEmulator, authInternal, "emulator-config-failed");
+ _assert(/^https?:\/\//.test(url), authInternal, "invalid-emulator-scheme");
+ const disableWarnings = !!(options === null || options === void 0 ? void 0 : options.disableWarnings);
+ const protocol = extractProtocol(url);
+ const { host, port } = extractHostAndPort(url);
+ const portStr = port === null ? "" : `:${port}`;
+ authInternal.config.emulator = { url: `${protocol}//${host}${portStr}/` };
+ authInternal.settings.appVerificationDisabledForTesting = true;
+ authInternal.emulatorConfig = Object.freeze({
+ host,
+ port,
+ protocol: protocol.replace(":", ""),
+ options: Object.freeze({ disableWarnings })
+ });
+ if (!disableWarnings) {
+ emitEmulatorWarning();
+ }
+}
+function extractProtocol(url) {
+ const protocolEnd = url.indexOf(":");
+ return protocolEnd < 0 ? "" : url.substr(0, protocolEnd + 1);
+}
+function extractHostAndPort(url) {
+ const protocol = extractProtocol(url);
+ const authority = /(\/\/)?([^?#/]+)/.exec(url.substr(protocol.length));
+ if (!authority) {
+ return { host: "", port: null };
+ }
+ const hostAndPort = authority[2].split("@").pop() || "";
+ const bracketedIPv6 = /^(\[[^\]]+\])(:|$)/.exec(hostAndPort);
+ if (bracketedIPv6) {
+ const host = bracketedIPv6[1];
+ return { host, port: parsePort(hostAndPort.substr(host.length + 1)) };
+ } else {
+ const [host, port] = hostAndPort.split(":");
+ return { host, port: parsePort(port) };
+ }
+}
+function parsePort(portStr) {
+ if (!portStr) {
+ return null;
+ }
+ const port = Number(portStr);
+ if (isNaN(port)) {
+ return null;
+ }
+ return port;
+}
+function emitEmulatorWarning() {
+ function attachBanner() {
+ const el2 = document.createElement("p");
+ const sty = el2.style;
+ el2.innerText = "Running in emulator mode. Do not use with production credentials.";
+ sty.position = "fixed";
+ sty.width = "100%";
+ sty.backgroundColor = "#ffffff";
+ sty.border = ".1em solid #000000";
+ sty.color = "#b50000";
+ sty.bottom = "0px";
+ sty.left = "0px";
+ sty.margin = "0px";
+ sty.zIndex = "10000";
+ sty.textAlign = "center";
+ el2.classList.add("firebase-emulator-warning");
+ document.body.appendChild(el2);
+ }
+ if (typeof console !== "undefined" && typeof console.info === "function") {
+ console.info("WARNING: You are using the Auth Emulator, which is intended for local testing only. Do not use with production credentials.");
+ }
+ if (typeof window !== "undefined" && typeof document !== "undefined") {
+ if (document.readyState === "loading") {
+ window.addEventListener("DOMContentLoaded", attachBanner);
+ } else {
+ attachBanner();
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthCredential {
+ constructor(providerId, signInMethod) {
+ this.providerId = providerId;
+ this.signInMethod = signInMethod;
+ }
+ toJSON() {
+ return debugFail("not implemented");
+ }
+ _getIdTokenResponse(_auth) {
+ return debugFail("not implemented");
+ }
+ _linkToIdToken(_auth, _idToken) {
+ return debugFail("not implemented");
+ }
+ _getReauthenticationResolver(_auth) {
+ return debugFail("not implemented");
+ }
+}
+async function updateEmailPassword(auth2, request) {
+ return _performApiRequest(auth2, "POST", "/v1/accounts:update", request);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signInWithPassword(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithPassword", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signInWithEmailLink$1(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary(auth2, request));
+}
+async function signInWithEmailLinkForLinking(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class EmailAuthCredential extends AuthCredential {
+ constructor(_email, _password, signInMethod, _tenantId = null) {
+ super("password", signInMethod);
+ this._email = _email;
+ this._password = _password;
+ this._tenantId = _tenantId;
+ }
+ static _fromEmailAndPassword(email, password) {
+ return new EmailAuthCredential(email, password, "password");
+ }
+ static _fromEmailAndCode(email, oobCode, tenantId = null) {
+ return new EmailAuthCredential(email, oobCode, "emailLink", tenantId);
+ }
+ toJSON() {
+ return {
+ email: this._email,
+ password: this._password,
+ signInMethod: this.signInMethod,
+ tenantId: this._tenantId
+ };
+ }
+ static fromJSON(json) {
+ const obj = typeof json === "string" ? JSON.parse(json) : json;
+ if ((obj === null || obj === void 0 ? void 0 : obj.email) && (obj === null || obj === void 0 ? void 0 : obj.password)) {
+ if (obj.signInMethod === "password") {
+ return this._fromEmailAndPassword(obj.email, obj.password);
+ } else if (obj.signInMethod === "emailLink") {
+ return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);
+ }
+ }
+ return null;
+ }
+ async _getIdTokenResponse(auth2) {
+ switch (this.signInMethod) {
+ case "password":
+ return signInWithPassword(auth2, {
+ returnSecureToken: true,
+ email: this._email,
+ password: this._password
+ });
+ case "emailLink":
+ return signInWithEmailLink$1(auth2, {
+ email: this._email,
+ oobCode: this._password
+ });
+ default:
+ _fail(auth2, "internal-error");
+ }
+ }
+ async _linkToIdToken(auth2, idToken) {
+ switch (this.signInMethod) {
+ case "password":
+ return updateEmailPassword(auth2, {
+ idToken,
+ returnSecureToken: true,
+ email: this._email,
+ password: this._password
+ });
+ case "emailLink":
+ return signInWithEmailLinkForLinking(auth2, {
+ idToken,
+ email: this._email,
+ oobCode: this._password
+ });
+ default:
+ _fail(auth2, "internal-error");
+ }
+ }
+ _getReauthenticationResolver(auth2) {
+ return this._getIdTokenResponse(auth2);
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signInWithIdp(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithIdp", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const IDP_REQUEST_URI$1 = "http://localhost";
+class OAuthCredential extends AuthCredential {
+ constructor() {
+ super(...arguments);
+ this.pendingToken = null;
+ }
+ static _fromParams(params) {
+ const cred = new OAuthCredential(params.providerId, params.signInMethod);
+ if (params.idToken || params.accessToken) {
+ if (params.idToken) {
+ cred.idToken = params.idToken;
+ }
+ if (params.accessToken) {
+ cred.accessToken = params.accessToken;
+ }
+ if (params.nonce && !params.pendingToken) {
+ cred.nonce = params.nonce;
+ }
+ if (params.pendingToken) {
+ cred.pendingToken = params.pendingToken;
+ }
+ } else if (params.oauthToken && params.oauthTokenSecret) {
+ cred.accessToken = params.oauthToken;
+ cred.secret = params.oauthTokenSecret;
+ } else {
+ _fail("argument-error");
+ }
+ return cred;
+ }
+ toJSON() {
+ return {
+ idToken: this.idToken,
+ accessToken: this.accessToken,
+ secret: this.secret,
+ nonce: this.nonce,
+ pendingToken: this.pendingToken,
+ providerId: this.providerId,
+ signInMethod: this.signInMethod
+ };
+ }
+ static fromJSON(json) {
+ const obj = typeof json === "string" ? JSON.parse(json) : json;
+ const { providerId, signInMethod } = obj, rest = __rest(obj, ["providerId", "signInMethod"]);
+ if (!providerId || !signInMethod) {
+ return null;
+ }
+ const cred = new OAuthCredential(providerId, signInMethod);
+ cred.idToken = rest.idToken || void 0;
+ cred.accessToken = rest.accessToken || void 0;
+ cred.secret = rest.secret;
+ cred.nonce = rest.nonce;
+ cred.pendingToken = rest.pendingToken || null;
+ return cred;
+ }
+ _getIdTokenResponse(auth2) {
+ const request = this.buildRequest();
+ return signInWithIdp(auth2, request);
+ }
+ _linkToIdToken(auth2, idToken) {
+ const request = this.buildRequest();
+ request.idToken = idToken;
+ return signInWithIdp(auth2, request);
+ }
+ _getReauthenticationResolver(auth2) {
+ const request = this.buildRequest();
+ request.autoCreate = false;
+ return signInWithIdp(auth2, request);
+ }
+ buildRequest() {
+ const request = {
+ requestUri: IDP_REQUEST_URI$1,
+ returnSecureToken: true
+ };
+ if (this.pendingToken) {
+ request.pendingToken = this.pendingToken;
+ } else {
+ const postBody = {};
+ if (this.idToken) {
+ postBody["id_token"] = this.idToken;
+ }
+ if (this.accessToken) {
+ postBody["access_token"] = this.accessToken;
+ }
+ if (this.secret) {
+ postBody["oauth_token_secret"] = this.secret;
+ }
+ postBody["providerId"] = this.providerId;
+ if (this.nonce && !this.pendingToken) {
+ postBody["nonce"] = this.nonce;
+ }
+ request.postBody = querystring(postBody);
+ }
+ return request;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function parseMode(mode) {
+ switch (mode) {
+ case "recoverEmail":
+ return "RECOVER_EMAIL";
+ case "resetPassword":
+ return "PASSWORD_RESET";
+ case "signIn":
+ return "EMAIL_SIGNIN";
+ case "verifyEmail":
+ return "VERIFY_EMAIL";
+ case "verifyAndChangeEmail":
+ return "VERIFY_AND_CHANGE_EMAIL";
+ case "revertSecondFactorAddition":
+ return "REVERT_SECOND_FACTOR_ADDITION";
+ default:
+ return null;
+ }
+}
+function parseDeepLink(url) {
+ const link = querystringDecode(extractQuerystring(url))["link"];
+ const doubleDeepLink = link ? querystringDecode(extractQuerystring(link))["deep_link_id"] : null;
+ const iOSDeepLink = querystringDecode(extractQuerystring(url))["deep_link_id"];
+ const iOSDoubleDeepLink = iOSDeepLink ? querystringDecode(extractQuerystring(iOSDeepLink))["link"] : null;
+ return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
+}
+class ActionCodeURL {
+ constructor(actionLink) {
+ var _a2, _b, _c2, _d, _e2, _f;
+ const searchParams = querystringDecode(extractQuerystring(actionLink));
+ const apiKey = (_a2 = searchParams["apiKey"]) !== null && _a2 !== void 0 ? _a2 : null;
+ const code = (_b = searchParams["oobCode"]) !== null && _b !== void 0 ? _b : null;
+ const operation = parseMode((_c2 = searchParams["mode"]) !== null && _c2 !== void 0 ? _c2 : null);
+ _assert(apiKey && code && operation, "argument-error");
+ this.apiKey = apiKey;
+ this.operation = operation;
+ this.code = code;
+ this.continueUrl = (_d = searchParams["continueUrl"]) !== null && _d !== void 0 ? _d : null;
+ this.languageCode = (_e2 = searchParams["languageCode"]) !== null && _e2 !== void 0 ? _e2 : null;
+ this.tenantId = (_f = searchParams["tenantId"]) !== null && _f !== void 0 ? _f : null;
+ }
+ static parseLink(link) {
+ const actionLink = parseDeepLink(link);
+ try {
+ return new ActionCodeURL(actionLink);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class EmailAuthProvider {
+ constructor() {
+ this.providerId = EmailAuthProvider.PROVIDER_ID;
+ }
+ static credential(email, password) {
+ return EmailAuthCredential._fromEmailAndPassword(email, password);
+ }
+ static credentialWithLink(email, emailLink) {
+ const actionCodeUrl = ActionCodeURL.parseLink(emailLink);
+ _assert(actionCodeUrl, "argument-error");
+ return EmailAuthCredential._fromEmailAndCode(email, actionCodeUrl.code, actionCodeUrl.tenantId);
+ }
+}
+EmailAuthProvider.PROVIDER_ID = "password";
+EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD = "password";
+EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD = "emailLink";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FederatedAuthProvider {
+ constructor(providerId) {
+ this.providerId = providerId;
+ this.defaultLanguageCode = null;
+ this.customParameters = {};
+ }
+ setDefaultLanguage(languageCode) {
+ this.defaultLanguageCode = languageCode;
+ }
+ setCustomParameters(customOAuthParameters) {
+ this.customParameters = customOAuthParameters;
+ return this;
+ }
+ getCustomParameters() {
+ return this.customParameters;
+ }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class BaseOAuthProvider extends FederatedAuthProvider {
+ constructor() {
+ super(...arguments);
+ this.scopes = [];
+ }
+ addScope(scope) {
+ if (!this.scopes.includes(scope)) {
+ this.scopes.push(scope);
+ }
+ return this;
+ }
+ getScopes() {
+ return [...this.scopes];
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FacebookAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("facebook.com");
+ }
+ static credential(accessToken) {
+ return OAuthCredential._fromParams({
+ providerId: FacebookAuthProvider.PROVIDER_ID,
+ signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,
+ accessToken
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return FacebookAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return FacebookAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
+ return null;
+ }
+ if (!tokenResponse.oauthAccessToken) {
+ return null;
+ }
+ try {
+ return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD = "facebook.com";
+FacebookAuthProvider.PROVIDER_ID = "facebook.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class GoogleAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("google.com");
+ this.addScope("profile");
+ }
+ static credential(idToken, accessToken) {
+ return OAuthCredential._fromParams({
+ providerId: GoogleAuthProvider.PROVIDER_ID,
+ signInMethod: GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,
+ idToken,
+ accessToken
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return GoogleAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return GoogleAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse) {
+ return null;
+ }
+ const { oauthIdToken, oauthAccessToken } = tokenResponse;
+ if (!oauthIdToken && !oauthAccessToken) {
+ return null;
+ }
+ try {
+ return GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD = "google.com";
+GoogleAuthProvider.PROVIDER_ID = "google.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class GithubAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("github.com");
+ }
+ static credential(accessToken) {
+ return OAuthCredential._fromParams({
+ providerId: GithubAuthProvider.PROVIDER_ID,
+ signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,
+ accessToken
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return GithubAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return GithubAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
+ return null;
+ }
+ if (!tokenResponse.oauthAccessToken) {
+ return null;
+ }
+ try {
+ return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+GithubAuthProvider.GITHUB_SIGN_IN_METHOD = "github.com";
+GithubAuthProvider.PROVIDER_ID = "github.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class TwitterAuthProvider extends BaseOAuthProvider {
+ constructor() {
+ super("twitter.com");
+ }
+ static credential(token, secret) {
+ return OAuthCredential._fromParams({
+ providerId: TwitterAuthProvider.PROVIDER_ID,
+ signInMethod: TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,
+ oauthToken: token,
+ oauthTokenSecret: secret
+ });
+ }
+ static credentialFromResult(userCredential) {
+ return TwitterAuthProvider.credentialFromTaggedObject(userCredential);
+ }
+ static credentialFromError(error) {
+ return TwitterAuthProvider.credentialFromTaggedObject(error.customData || {});
+ }
+ static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
+ if (!tokenResponse) {
+ return null;
+ }
+ const { oauthAccessToken, oauthTokenSecret } = tokenResponse;
+ if (!oauthAccessToken || !oauthTokenSecret) {
+ return null;
+ }
+ try {
+ return TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);
+ } catch (_a2) {
+ return null;
+ }
+ }
+}
+TwitterAuthProvider.TWITTER_SIGN_IN_METHOD = "twitter.com";
+TwitterAuthProvider.PROVIDER_ID = "twitter.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function signUp(auth2, request) {
+ return _performSignInRequest(auth2, "POST", "/v1/accounts:signUp", _addTidIfNecessary(auth2, request));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class UserCredentialImpl {
+ constructor(params) {
+ this.user = params.user;
+ this.providerId = params.providerId;
+ this._tokenResponse = params._tokenResponse;
+ this.operationType = params.operationType;
+ }
+ static async _fromIdTokenResponse(auth2, operationType, idTokenResponse, isAnonymous = false) {
+ const user = await UserImpl._fromIdTokenResponse(auth2, idTokenResponse, isAnonymous);
+ const providerId = providerIdForResponse(idTokenResponse);
+ const userCred = new UserCredentialImpl({
+ user,
+ providerId,
+ _tokenResponse: idTokenResponse,
+ operationType
+ });
+ return userCred;
+ }
+ static async _forOperation(user, operationType, response) {
+ await user._updateTokensIfNecessary(response, true);
+ const providerId = providerIdForResponse(response);
+ return new UserCredentialImpl({
+ user,
+ providerId,
+ _tokenResponse: response,
+ operationType
+ });
+ }
+}
+function providerIdForResponse(response) {
+ if (response.providerId) {
+ return response.providerId;
+ }
+ if ("phoneNumber" in response) {
+ return "phone";
+ }
+ return null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class MultiFactorError extends FirebaseError {
+ constructor(auth2, error, operationType, user) {
+ var _a2;
+ super(error.code, error.message);
+ this.operationType = operationType;
+ this.user = user;
+ Object.setPrototypeOf(this, MultiFactorError.prototype);
+ this.customData = {
+ appName: auth2.name,
+ tenantId: (_a2 = auth2.tenantId) !== null && _a2 !== void 0 ? _a2 : void 0,
+ _serverResponse: error.customData._serverResponse,
+ operationType
+ };
+ }
+ static _fromErrorAndOperation(auth2, error, operationType, user) {
+ return new MultiFactorError(auth2, error, operationType, user);
+ }
+}
+function _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential, user) {
+ const idTokenProvider = operationType === "reauthenticate" ? credential._getReauthenticationResolver(auth2) : credential._getIdTokenResponse(auth2);
+ return idTokenProvider.catch((error) => {
+ if (error.code === `auth/${"multi-factor-auth-required"}`) {
+ throw MultiFactorError._fromErrorAndOperation(auth2, error, operationType, user);
+ }
+ throw error;
+ });
+}
+async function _link$1(user, credential, bypassAuthState = false) {
+ const response = await _logoutIfInvalidated(user, credential._linkToIdToken(user.auth, await user.getIdToken()), bypassAuthState);
+ return UserCredentialImpl._forOperation(user, "link", response);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _reauthenticate(user, credential, bypassAuthState = false) {
+ const { auth: auth2 } = user;
+ const operationType = "reauthenticate";
+ try {
+ const response = await _logoutIfInvalidated(user, _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential, user), bypassAuthState);
+ _assert(response.idToken, auth2, "internal-error");
+ const parsed = _parseToken(response.idToken);
+ _assert(parsed, auth2, "internal-error");
+ const { sub: localId } = parsed;
+ _assert(user.uid === localId, auth2, "user-mismatch");
+ return UserCredentialImpl._forOperation(user, operationType, response);
+ } catch (e) {
+ if ((e === null || e === void 0 ? void 0 : e.code) === `auth/${"user-not-found"}`) {
+ _fail(auth2, "user-mismatch");
+ }
+ throw e;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _signInWithCredential(auth2, credential, bypassAuthState = false) {
+ const operationType = "signIn";
+ const response = await _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential);
+ const userCredential = await UserCredentialImpl._fromIdTokenResponse(auth2, operationType, response);
+ if (!bypassAuthState) {
+ await auth2._updateCurrentUser(userCredential.user);
+ }
+ return userCredential;
+}
+async function signInWithCredential(auth2, credential) {
+ return _signInWithCredential(_castAuth(auth2), credential);
+}
+async function createUserWithEmailAndPassword(auth2, email, password) {
+ const authInternal = _castAuth(auth2);
+ const response = await signUp(authInternal, {
+ returnSecureToken: true,
+ email,
+ password
+ });
+ const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn", response);
+ await authInternal._updateCurrentUser(userCredential.user);
+ return userCredential;
+}
+function signInWithEmailAndPassword(auth2, email, password) {
+ return signInWithCredential(getModularInstance(auth2), EmailAuthProvider.credential(email, password));
+}
+function onIdTokenChanged(auth2, nextOrObserver, error, completed) {
+ return getModularInstance(auth2).onIdTokenChanged(nextOrObserver, error, completed);
+}
+function beforeAuthStateChanged(auth2, callback, onAbort) {
+ return getModularInstance(auth2).beforeAuthStateChanged(callback, onAbort);
+}
+function onAuthStateChanged(auth2, nextOrObserver, error, completed) {
+ return getModularInstance(auth2).onAuthStateChanged(nextOrObserver, error, completed);
+}
+function signOut(auth2) {
+ return getModularInstance(auth2).signOut();
+}
+const STORAGE_AVAILABLE_KEY = "__sak";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class BrowserPersistenceClass {
+ constructor(storageRetriever, type) {
+ this.storageRetriever = storageRetriever;
+ this.type = type;
+ }
+ _isAvailable() {
+ try {
+ if (!this.storage) {
+ return Promise.resolve(false);
+ }
+ this.storage.setItem(STORAGE_AVAILABLE_KEY, "1");
+ this.storage.removeItem(STORAGE_AVAILABLE_KEY);
+ return Promise.resolve(true);
+ } catch (_a2) {
+ return Promise.resolve(false);
+ }
+ }
+ _set(key, value) {
+ this.storage.setItem(key, JSON.stringify(value));
+ return Promise.resolve();
+ }
+ _get(key) {
+ const json = this.storage.getItem(key);
+ return Promise.resolve(json ? JSON.parse(json) : null);
+ }
+ _remove(key) {
+ this.storage.removeItem(key);
+ return Promise.resolve();
+ }
+ get storage() {
+ return this.storageRetriever();
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _iframeCannotSyncWebStorage() {
+ const ua2 = getUA();
+ return _isSafari(ua2) || _isIOS(ua2);
+}
+const _POLLING_INTERVAL_MS$1 = 1e3;
+const IE10_LOCAL_STORAGE_SYNC_DELAY = 10;
+class BrowserLocalPersistence extends BrowserPersistenceClass {
+ constructor() {
+ super(() => window.localStorage, "LOCAL");
+ this.boundEventHandler = (event, poll) => this.onStorageEvent(event, poll);
+ this.listeners = {};
+ this.localCache = {};
+ this.pollTimer = null;
+ this.safariLocalStorageNotSynced = _iframeCannotSyncWebStorage() && _isIframe();
+ this.fallbackToPolling = _isMobileBrowser();
+ this._shouldAllowMigration = true;
+ }
+ forAllChangedKeys(cb2) {
+ for (const key of Object.keys(this.listeners)) {
+ const newValue = this.storage.getItem(key);
+ const oldValue = this.localCache[key];
+ if (newValue !== oldValue) {
+ cb2(key, oldValue, newValue);
+ }
+ }
+ }
+ onStorageEvent(event, poll = false) {
+ if (!event.key) {
+ this.forAllChangedKeys((key2, _oldValue, newValue) => {
+ this.notifyListeners(key2, newValue);
+ });
+ return;
+ }
+ const key = event.key;
+ if (poll) {
+ this.detachListener();
+ } else {
+ this.stopPolling();
+ }
+ if (this.safariLocalStorageNotSynced) {
+ const storedValue2 = this.storage.getItem(key);
+ if (event.newValue !== storedValue2) {
+ if (event.newValue !== null) {
+ this.storage.setItem(key, event.newValue);
+ } else {
+ this.storage.removeItem(key);
+ }
+ } else if (this.localCache[key] === event.newValue && !poll) {
+ return;
+ }
+ }
+ const triggerListeners = () => {
+ const storedValue2 = this.storage.getItem(key);
+ if (!poll && this.localCache[key] === storedValue2) {
+ return;
+ }
+ this.notifyListeners(key, storedValue2);
+ };
+ const storedValue = this.storage.getItem(key);
+ if (_isIE10() && storedValue !== event.newValue && event.newValue !== event.oldValue) {
+ setTimeout(triggerListeners, IE10_LOCAL_STORAGE_SYNC_DELAY);
+ } else {
+ triggerListeners();
+ }
+ }
+ notifyListeners(key, value) {
+ this.localCache[key] = value;
+ const listeners = this.listeners[key];
+ if (listeners) {
+ for (const listener of Array.from(listeners)) {
+ listener(value ? JSON.parse(value) : value);
+ }
+ }
+ }
+ startPolling() {
+ this.stopPolling();
+ this.pollTimer = setInterval(() => {
+ this.forAllChangedKeys((key, oldValue, newValue) => {
+ this.onStorageEvent(
+ new StorageEvent("storage", {
+ key,
+ oldValue,
+ newValue
+ }),
+ true
+ );
+ });
+ }, _POLLING_INTERVAL_MS$1);
+ }
+ stopPolling() {
+ if (this.pollTimer) {
+ clearInterval(this.pollTimer);
+ this.pollTimer = null;
+ }
+ }
+ attachListener() {
+ window.addEventListener("storage", this.boundEventHandler);
+ }
+ detachListener() {
+ window.removeEventListener("storage", this.boundEventHandler);
+ }
+ _addListener(key, listener) {
+ if (Object.keys(this.listeners).length === 0) {
+ if (this.fallbackToPolling) {
+ this.startPolling();
+ } else {
+ this.attachListener();
+ }
+ }
+ if (!this.listeners[key]) {
+ this.listeners[key] = /* @__PURE__ */ new Set();
+ this.localCache[key] = this.storage.getItem(key);
+ }
+ this.listeners[key].add(listener);
+ }
+ _removeListener(key, listener) {
+ if (this.listeners[key]) {
+ this.listeners[key].delete(listener);
+ if (this.listeners[key].size === 0) {
+ delete this.listeners[key];
+ }
+ }
+ if (Object.keys(this.listeners).length === 0) {
+ this.detachListener();
+ this.stopPolling();
+ }
+ }
+ async _set(key, value) {
+ await super._set(key, value);
+ this.localCache[key] = JSON.stringify(value);
+ }
+ async _get(key) {
+ const value = await super._get(key);
+ this.localCache[key] = JSON.stringify(value);
+ return value;
+ }
+ async _remove(key) {
+ await super._remove(key);
+ delete this.localCache[key];
+ }
+}
+BrowserLocalPersistence.type = "LOCAL";
+const browserLocalPersistence = BrowserLocalPersistence;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class BrowserSessionPersistence extends BrowserPersistenceClass {
+ constructor() {
+ super(() => window.sessionStorage, "SESSION");
+ }
+ _addListener(_key, _listener) {
+ return;
+ }
+ _removeListener(_key, _listener) {
+ return;
+ }
+}
+BrowserSessionPersistence.type = "SESSION";
+const browserSessionPersistence = BrowserSessionPersistence;
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _allSettled(promises) {
+ return Promise.all(promises.map(async (promise) => {
+ try {
+ const value = await promise;
+ return {
+ fulfilled: true,
+ value
+ };
+ } catch (reason) {
+ return {
+ fulfilled: false,
+ reason
+ };
+ }
+ }));
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Receiver {
+ constructor(eventTarget) {
+ this.eventTarget = eventTarget;
+ this.handlersMap = {};
+ this.boundEventHandler = this.handleEvent.bind(this);
+ }
+ static _getInstance(eventTarget) {
+ const existingInstance = this.receivers.find((receiver) => receiver.isListeningto(eventTarget));
+ if (existingInstance) {
+ return existingInstance;
+ }
+ const newInstance = new Receiver(eventTarget);
+ this.receivers.push(newInstance);
+ return newInstance;
+ }
+ isListeningto(eventTarget) {
+ return this.eventTarget === eventTarget;
+ }
+ async handleEvent(event) {
+ const messageEvent = event;
+ const { eventId, eventType, data } = messageEvent.data;
+ const handlers = this.handlersMap[eventType];
+ if (!(handlers === null || handlers === void 0 ? void 0 : handlers.size)) {
+ return;
+ }
+ messageEvent.ports[0].postMessage({
+ status: "ack",
+ eventId,
+ eventType
+ });
+ const promises = Array.from(handlers).map(async (handler) => handler(messageEvent.origin, data));
+ const response = await _allSettled(promises);
+ messageEvent.ports[0].postMessage({
+ status: "done",
+ eventId,
+ eventType,
+ response
+ });
+ }
+ _subscribe(eventType, eventHandler) {
+ if (Object.keys(this.handlersMap).length === 0) {
+ this.eventTarget.addEventListener("message", this.boundEventHandler);
+ }
+ if (!this.handlersMap[eventType]) {
+ this.handlersMap[eventType] = /* @__PURE__ */ new Set();
+ }
+ this.handlersMap[eventType].add(eventHandler);
+ }
+ _unsubscribe(eventType, eventHandler) {
+ if (this.handlersMap[eventType] && eventHandler) {
+ this.handlersMap[eventType].delete(eventHandler);
+ }
+ if (!eventHandler || this.handlersMap[eventType].size === 0) {
+ delete this.handlersMap[eventType];
+ }
+ if (Object.keys(this.handlersMap).length === 0) {
+ this.eventTarget.removeEventListener("message", this.boundEventHandler);
+ }
+ }
+}
+Receiver.receivers = [];
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _generateEventId(prefix = "", digits = 10) {
+ let random = "";
+ for (let i = 0; i < digits; i++) {
+ random += Math.floor(Math.random() * 10);
+ }
+ return prefix + random;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Sender {
+ constructor(target) {
+ this.target = target;
+ this.handlers = /* @__PURE__ */ new Set();
+ }
+ removeMessageHandler(handler) {
+ if (handler.messageChannel) {
+ handler.messageChannel.port1.removeEventListener("message", handler.onMessage);
+ handler.messageChannel.port1.close();
+ }
+ this.handlers.delete(handler);
+ }
+ async _send(eventType, data, timeout = 50) {
+ const messageChannel = typeof MessageChannel !== "undefined" ? new MessageChannel() : null;
+ if (!messageChannel) {
+ throw new Error("connection_unavailable");
+ }
+ let completionTimer;
+ let handler;
+ return new Promise((resolve, reject) => {
+ const eventId = _generateEventId("", 20);
+ messageChannel.port1.start();
+ const ackTimer = setTimeout(() => {
+ reject(new Error("unsupported_event"));
+ }, timeout);
+ handler = {
+ messageChannel,
+ onMessage(event) {
+ const messageEvent = event;
+ if (messageEvent.data.eventId !== eventId) {
+ return;
+ }
+ switch (messageEvent.data.status) {
+ case "ack":
+ clearTimeout(ackTimer);
+ completionTimer = setTimeout(() => {
+ reject(new Error("timeout"));
+ }, 3e3);
+ break;
+ case "done":
+ clearTimeout(completionTimer);
+ resolve(messageEvent.data.response);
+ break;
+ default:
+ clearTimeout(ackTimer);
+ clearTimeout(completionTimer);
+ reject(new Error("invalid_response"));
+ break;
+ }
+ }
+ };
+ this.handlers.add(handler);
+ messageChannel.port1.addEventListener("message", handler.onMessage);
+ this.target.postMessage({
+ eventType,
+ eventId,
+ data
+ }, [messageChannel.port2]);
+ }).finally(() => {
+ if (handler) {
+ this.removeMessageHandler(handler);
+ }
+ });
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _window() {
+ return window;
+}
+function _setWindowLocation(url) {
+ _window().location.href = url;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _isWorker() {
+ return typeof _window()["WorkerGlobalScope"] !== "undefined" && typeof _window()["importScripts"] === "function";
+}
+async function _getActiveServiceWorker() {
+ if (!(navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker)) {
+ return null;
+ }
+ try {
+ const registration = await navigator.serviceWorker.ready;
+ return registration.active;
+ } catch (_a2) {
+ return null;
+ }
+}
+function _getServiceWorkerController() {
+ var _a2;
+ return ((_a2 = navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker) === null || _a2 === void 0 ? void 0 : _a2.controller) || null;
+}
+function _getWorkerGlobalScope() {
+ return _isWorker() ? self : null;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DB_NAME = "firebaseLocalStorageDb";
+const DB_VERSION = 1;
+const DB_OBJECTSTORE_NAME = "firebaseLocalStorage";
+const DB_DATA_KEYPATH = "fbase_key";
+class DBPromise {
+ constructor(request) {
+ this.request = request;
+ }
+ toPromise() {
+ return new Promise((resolve, reject) => {
+ this.request.addEventListener("success", () => {
+ resolve(this.request.result);
+ });
+ this.request.addEventListener("error", () => {
+ reject(this.request.error);
+ });
+ });
+ }
+}
+function getObjectStore(db2, isReadWrite) {
+ return db2.transaction([DB_OBJECTSTORE_NAME], isReadWrite ? "readwrite" : "readonly").objectStore(DB_OBJECTSTORE_NAME);
+}
+function _deleteDatabase() {
+ const request = indexedDB.deleteDatabase(DB_NAME);
+ return new DBPromise(request).toPromise();
+}
+function _openDatabase() {
+ const request = indexedDB.open(DB_NAME, DB_VERSION);
+ return new Promise((resolve, reject) => {
+ request.addEventListener("error", () => {
+ reject(request.error);
+ });
+ request.addEventListener("upgradeneeded", () => {
+ const db2 = request.result;
+ try {
+ db2.createObjectStore(DB_OBJECTSTORE_NAME, { keyPath: DB_DATA_KEYPATH });
+ } catch (e) {
+ reject(e);
+ }
+ });
+ request.addEventListener("success", async () => {
+ const db2 = request.result;
+ if (!db2.objectStoreNames.contains(DB_OBJECTSTORE_NAME)) {
+ db2.close();
+ await _deleteDatabase();
+ resolve(await _openDatabase());
+ } else {
+ resolve(db2);
+ }
+ });
+ });
+}
+async function _putObject(db2, key, value) {
+ const request = getObjectStore(db2, true).put({
+ [DB_DATA_KEYPATH]: key,
+ value
+ });
+ return new DBPromise(request).toPromise();
+}
+async function getObject(db2, key) {
+ const request = getObjectStore(db2, false).get(key);
+ const data = await new DBPromise(request).toPromise();
+ return data === void 0 ? null : data.value;
+}
+function _deleteObject(db2, key) {
+ const request = getObjectStore(db2, true).delete(key);
+ return new DBPromise(request).toPromise();
+}
+const _POLLING_INTERVAL_MS = 800;
+const _TRANSACTION_RETRY_COUNT = 3;
+class IndexedDBLocalPersistence {
+ constructor() {
+ this.type = "LOCAL";
+ this._shouldAllowMigration = true;
+ this.listeners = {};
+ this.localCache = {};
+ this.pollTimer = null;
+ this.pendingWrites = 0;
+ this.receiver = null;
+ this.sender = null;
+ this.serviceWorkerReceiverAvailable = false;
+ this.activeServiceWorker = null;
+ this._workerInitializationPromise = this.initializeServiceWorkerMessaging().then(() => {
+ }, () => {
+ });
+ }
+ async _openDb() {
+ if (this.db) {
+ return this.db;
+ }
+ this.db = await _openDatabase();
+ return this.db;
+ }
+ async _withRetries(op) {
+ let numAttempts = 0;
+ while (true) {
+ try {
+ const db2 = await this._openDb();
+ return await op(db2);
+ } catch (e) {
+ if (numAttempts++ > _TRANSACTION_RETRY_COUNT) {
+ throw e;
+ }
+ if (this.db) {
+ this.db.close();
+ this.db = void 0;
+ }
+ }
+ }
+ }
+ async initializeServiceWorkerMessaging() {
+ return _isWorker() ? this.initializeReceiver() : this.initializeSender();
+ }
+ async initializeReceiver() {
+ this.receiver = Receiver._getInstance(_getWorkerGlobalScope());
+ this.receiver._subscribe("keyChanged", async (_origin, data) => {
+ const keys = await this._poll();
+ return {
+ keyProcessed: keys.includes(data.key)
+ };
+ });
+ this.receiver._subscribe("ping", async (_origin, _data) => {
+ return ["keyChanged"];
+ });
+ }
+ async initializeSender() {
+ var _a2, _b;
+ this.activeServiceWorker = await _getActiveServiceWorker();
+ if (!this.activeServiceWorker) {
+ return;
+ }
+ this.sender = new Sender(this.activeServiceWorker);
+ const results = await this.sender._send("ping", {}, 800);
+ if (!results) {
+ return;
+ }
+ if (((_a2 = results[0]) === null || _a2 === void 0 ? void 0 : _a2.fulfilled) && ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.value.includes("keyChanged"))) {
+ this.serviceWorkerReceiverAvailable = true;
+ }
+ }
+ async notifyServiceWorker(key) {
+ if (!this.sender || !this.activeServiceWorker || _getServiceWorkerController() !== this.activeServiceWorker) {
+ return;
+ }
+ try {
+ await this.sender._send(
+ "keyChanged",
+ { key },
+ this.serviceWorkerReceiverAvailable ? 800 : 50
+ );
+ } catch (_a2) {
+ }
+ }
+ async _isAvailable() {
+ try {
+ if (!indexedDB) {
+ return false;
+ }
+ const db2 = await _openDatabase();
+ await _putObject(db2, STORAGE_AVAILABLE_KEY, "1");
+ await _deleteObject(db2, STORAGE_AVAILABLE_KEY);
+ return true;
+ } catch (_a2) {
+ }
+ return false;
+ }
+ async _withPendingWrite(write) {
+ this.pendingWrites++;
+ try {
+ await write();
+ } finally {
+ this.pendingWrites--;
+ }
+ }
+ async _set(key, value) {
+ return this._withPendingWrite(async () => {
+ await this._withRetries((db2) => _putObject(db2, key, value));
+ this.localCache[key] = value;
+ return this.notifyServiceWorker(key);
+ });
+ }
+ async _get(key) {
+ const obj = await this._withRetries((db2) => getObject(db2, key));
+ this.localCache[key] = obj;
+ return obj;
+ }
+ async _remove(key) {
+ return this._withPendingWrite(async () => {
+ await this._withRetries((db2) => _deleteObject(db2, key));
+ delete this.localCache[key];
+ return this.notifyServiceWorker(key);
+ });
+ }
+ async _poll() {
+ const result = await this._withRetries((db2) => {
+ const getAllRequest = getObjectStore(db2, false).getAll();
+ return new DBPromise(getAllRequest).toPromise();
+ });
+ if (!result) {
+ return [];
+ }
+ if (this.pendingWrites !== 0) {
+ return [];
+ }
+ const keys = [];
+ const keysInResult = /* @__PURE__ */ new Set();
+ for (const { fbase_key: key, value } of result) {
+ keysInResult.add(key);
+ if (JSON.stringify(this.localCache[key]) !== JSON.stringify(value)) {
+ this.notifyListeners(key, value);
+ keys.push(key);
+ }
+ }
+ for (const localKey of Object.keys(this.localCache)) {
+ if (this.localCache[localKey] && !keysInResult.has(localKey)) {
+ this.notifyListeners(localKey, null);
+ keys.push(localKey);
+ }
+ }
+ return keys;
+ }
+ notifyListeners(key, newValue) {
+ this.localCache[key] = newValue;
+ const listeners = this.listeners[key];
+ if (listeners) {
+ for (const listener of Array.from(listeners)) {
+ listener(newValue);
+ }
+ }
+ }
+ startPolling() {
+ this.stopPolling();
+ this.pollTimer = setInterval(async () => this._poll(), _POLLING_INTERVAL_MS);
+ }
+ stopPolling() {
+ if (this.pollTimer) {
+ clearInterval(this.pollTimer);
+ this.pollTimer = null;
+ }
+ }
+ _addListener(key, listener) {
+ if (Object.keys(this.listeners).length === 0) {
+ this.startPolling();
+ }
+ if (!this.listeners[key]) {
+ this.listeners[key] = /* @__PURE__ */ new Set();
+ void this._get(key);
+ }
+ this.listeners[key].add(listener);
+ }
+ _removeListener(key, listener) {
+ if (this.listeners[key]) {
+ this.listeners[key].delete(listener);
+ if (this.listeners[key].size === 0) {
+ delete this.listeners[key];
+ }
+ }
+ if (Object.keys(this.listeners).length === 0) {
+ this.stopPolling();
+ }
+ }
+}
+IndexedDBLocalPersistence.type = "LOCAL";
+const indexedDBLocalPersistence = IndexedDBLocalPersistence;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getScriptParentElement() {
+ var _a2, _b;
+ return (_b = (_a2 = document.getElementsByTagName("head")) === null || _a2 === void 0 ? void 0 : _a2[0]) !== null && _b !== void 0 ? _b : document;
+}
+function _loadJS(url) {
+ return new Promise((resolve, reject) => {
+ const el2 = document.createElement("script");
+ el2.setAttribute("src", url);
+ el2.onload = resolve;
+ el2.onerror = (e) => {
+ const error = _createError("internal-error");
+ error.customData = e;
+ reject(error);
+ };
+ el2.type = "text/javascript";
+ el2.charset = "UTF-8";
+ getScriptParentElement().appendChild(el2);
+ });
+}
+function _generateCallbackName(prefix) {
+ return `__${prefix}${Math.floor(Math.random() * 1e6)}`;
+}
+new Delay(3e4, 6e4);
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _withDefaultResolver(auth2, resolverOverride) {
+ if (resolverOverride) {
+ return _getInstance(resolverOverride);
+ }
+ _assert(auth2._popupRedirectResolver, auth2, "argument-error");
+ return auth2._popupRedirectResolver;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class IdpCredential extends AuthCredential {
+ constructor(params) {
+ super("custom", "custom");
+ this.params = params;
+ }
+ _getIdTokenResponse(auth2) {
+ return signInWithIdp(auth2, this._buildIdpRequest());
+ }
+ _linkToIdToken(auth2, idToken) {
+ return signInWithIdp(auth2, this._buildIdpRequest(idToken));
+ }
+ _getReauthenticationResolver(auth2) {
+ return signInWithIdp(auth2, this._buildIdpRequest());
+ }
+ _buildIdpRequest(idToken) {
+ const request = {
+ requestUri: this.params.requestUri,
+ sessionId: this.params.sessionId,
+ postBody: this.params.postBody,
+ tenantId: this.params.tenantId,
+ pendingToken: this.params.pendingToken,
+ returnSecureToken: true,
+ returnIdpCredential: true
+ };
+ if (idToken) {
+ request.idToken = idToken;
+ }
+ return request;
+ }
+}
+function _signIn(params) {
+ return _signInWithCredential(params.auth, new IdpCredential(params), params.bypassAuthState);
+}
+function _reauth(params) {
+ const { auth: auth2, user } = params;
+ _assert(user, auth2, "internal-error");
+ return _reauthenticate(user, new IdpCredential(params), params.bypassAuthState);
+}
+async function _link(params) {
+ const { auth: auth2, user } = params;
+ _assert(user, auth2, "internal-error");
+ return _link$1(user, new IdpCredential(params), params.bypassAuthState);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AbstractPopupRedirectOperation {
+ constructor(auth2, filter, resolver, user, bypassAuthState = false) {
+ this.auth = auth2;
+ this.resolver = resolver;
+ this.user = user;
+ this.bypassAuthState = bypassAuthState;
+ this.pendingPromise = null;
+ this.eventManager = null;
+ this.filter = Array.isArray(filter) ? filter : [filter];
+ }
+ execute() {
+ return new Promise(async (resolve, reject) => {
+ this.pendingPromise = { resolve, reject };
+ try {
+ this.eventManager = await this.resolver._initialize(this.auth);
+ await this.onExecution();
+ this.eventManager.registerConsumer(this);
+ } catch (e) {
+ this.reject(e);
+ }
+ });
+ }
+ async onAuthEvent(event) {
+ const { urlResponse, sessionId, postBody, tenantId, error, type } = event;
+ if (error) {
+ this.reject(error);
+ return;
+ }
+ const params = {
+ auth: this.auth,
+ requestUri: urlResponse,
+ sessionId,
+ tenantId: tenantId || void 0,
+ postBody: postBody || void 0,
+ user: this.user,
+ bypassAuthState: this.bypassAuthState
+ };
+ try {
+ this.resolve(await this.getIdpTask(type)(params));
+ } catch (e) {
+ this.reject(e);
+ }
+ }
+ onError(error) {
+ this.reject(error);
+ }
+ getIdpTask(type) {
+ switch (type) {
+ case "signInViaPopup":
+ case "signInViaRedirect":
+ return _signIn;
+ case "linkViaPopup":
+ case "linkViaRedirect":
+ return _link;
+ case "reauthViaPopup":
+ case "reauthViaRedirect":
+ return _reauth;
+ default:
+ _fail(this.auth, "internal-error");
+ }
+ }
+ resolve(cred) {
+ debugAssert(this.pendingPromise, "Pending promise was never set");
+ this.pendingPromise.resolve(cred);
+ this.unregisterAndCleanUp();
+ }
+ reject(error) {
+ debugAssert(this.pendingPromise, "Pending promise was never set");
+ this.pendingPromise.reject(error);
+ this.unregisterAndCleanUp();
+ }
+ unregisterAndCleanUp() {
+ if (this.eventManager) {
+ this.eventManager.unregisterConsumer(this);
+ }
+ this.pendingPromise = null;
+ this.cleanUp();
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const _POLL_WINDOW_CLOSE_TIMEOUT = new Delay(2e3, 1e4);
+async function signInWithPopup(auth2, provider2, resolver) {
+ const authInternal = _castAuth(auth2);
+ _assertInstanceOf(auth2, provider2, FederatedAuthProvider);
+ const resolverInternal = _withDefaultResolver(authInternal, resolver);
+ const action = new PopupOperation(authInternal, "signInViaPopup", provider2, resolverInternal);
+ return action.executeNotNull();
+}
+class PopupOperation extends AbstractPopupRedirectOperation {
+ constructor(auth2, filter, provider2, resolver, user) {
+ super(auth2, filter, resolver, user);
+ this.provider = provider2;
+ this.authWindow = null;
+ this.pollId = null;
+ if (PopupOperation.currentPopupAction) {
+ PopupOperation.currentPopupAction.cancel();
+ }
+ PopupOperation.currentPopupAction = this;
+ }
+ async executeNotNull() {
+ const result = await this.execute();
+ _assert(result, this.auth, "internal-error");
+ return result;
+ }
+ async onExecution() {
+ debugAssert(this.filter.length === 1, "Popup operations only handle one event");
+ const eventId = _generateEventId();
+ this.authWindow = await this.resolver._openPopup(
+ this.auth,
+ this.provider,
+ this.filter[0],
+ eventId
+ );
+ this.authWindow.associatedEvent = eventId;
+ this.resolver._originValidation(this.auth).catch((e) => {
+ this.reject(e);
+ });
+ this.resolver._isIframeWebStorageSupported(this.auth, (isSupported) => {
+ if (!isSupported) {
+ this.reject(_createError(this.auth, "web-storage-unsupported"));
+ }
+ });
+ this.pollUserCancellation();
+ }
+ get eventId() {
+ var _a2;
+ return ((_a2 = this.authWindow) === null || _a2 === void 0 ? void 0 : _a2.associatedEvent) || null;
+ }
+ cancel() {
+ this.reject(_createError(this.auth, "cancelled-popup-request"));
+ }
+ cleanUp() {
+ if (this.authWindow) {
+ this.authWindow.close();
+ }
+ if (this.pollId) {
+ window.clearTimeout(this.pollId);
+ }
+ this.authWindow = null;
+ this.pollId = null;
+ PopupOperation.currentPopupAction = null;
+ }
+ pollUserCancellation() {
+ const poll = () => {
+ var _a2, _b;
+ if ((_b = (_a2 = this.authWindow) === null || _a2 === void 0 ? void 0 : _a2.window) === null || _b === void 0 ? void 0 : _b.closed) {
+ this.pollId = window.setTimeout(() => {
+ this.pollId = null;
+ this.reject(_createError(this.auth, "popup-closed-by-user"));
+ }, 2e3);
+ return;
+ }
+ this.pollId = window.setTimeout(poll, _POLL_WINDOW_CLOSE_TIMEOUT.get());
+ };
+ poll();
+ }
+}
+PopupOperation.currentPopupAction = null;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const PENDING_REDIRECT_KEY = "pendingRedirect";
+const redirectOutcomeMap = /* @__PURE__ */ new Map();
+class RedirectAction extends AbstractPopupRedirectOperation {
+ constructor(auth2, resolver, bypassAuthState = false) {
+ super(auth2, [
+ "signInViaRedirect",
+ "linkViaRedirect",
+ "reauthViaRedirect",
+ "unknown"
+ ], resolver, void 0, bypassAuthState);
+ this.eventId = null;
+ }
+ async execute() {
+ let readyOutcome = redirectOutcomeMap.get(this.auth._key());
+ if (!readyOutcome) {
+ try {
+ const hasPendingRedirect = await _getAndClearPendingRedirectStatus(this.resolver, this.auth);
+ const result = hasPendingRedirect ? await super.execute() : null;
+ readyOutcome = () => Promise.resolve(result);
+ } catch (e) {
+ readyOutcome = () => Promise.reject(e);
+ }
+ redirectOutcomeMap.set(this.auth._key(), readyOutcome);
+ }
+ if (!this.bypassAuthState) {
+ redirectOutcomeMap.set(this.auth._key(), () => Promise.resolve(null));
+ }
+ return readyOutcome();
+ }
+ async onAuthEvent(event) {
+ if (event.type === "signInViaRedirect") {
+ return super.onAuthEvent(event);
+ } else if (event.type === "unknown") {
+ this.resolve(null);
+ return;
+ }
+ if (event.eventId) {
+ const user = await this.auth._redirectUserForId(event.eventId);
+ if (user) {
+ this.user = user;
+ return super.onAuthEvent(event);
+ } else {
+ this.resolve(null);
+ }
+ }
+ }
+ async onExecution() {
+ }
+ cleanUp() {
+ }
+}
+async function _getAndClearPendingRedirectStatus(resolver, auth2) {
+ const key = pendingRedirectKey(auth2);
+ const persistence = resolverPersistence(resolver);
+ if (!await persistence._isAvailable()) {
+ return false;
+ }
+ const hasPendingRedirect = await persistence._get(key) === "true";
+ await persistence._remove(key);
+ return hasPendingRedirect;
+}
+function _overrideRedirectResult(auth2, result) {
+ redirectOutcomeMap.set(auth2._key(), result);
+}
+function resolverPersistence(resolver) {
+ return _getInstance(resolver._redirectPersistence);
+}
+function pendingRedirectKey(auth2) {
+ return _persistenceKeyName(PENDING_REDIRECT_KEY, auth2.config.apiKey, auth2.name);
+}
+async function _getRedirectResult(auth2, resolverExtern, bypassAuthState = false) {
+ const authInternal = _castAuth(auth2);
+ const resolver = _withDefaultResolver(authInternal, resolverExtern);
+ const action = new RedirectAction(authInternal, resolver, bypassAuthState);
+ const result = await action.execute();
+ if (result && !bypassAuthState) {
+ delete result.user._redirectEventId;
+ await authInternal._persistUserIfCurrent(result.user);
+ await authInternal._setRedirectUser(null, resolverExtern);
+ }
+ return result;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1e3;
+class AuthEventManager {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.cachedEventUids = /* @__PURE__ */ new Set();
+ this.consumers = /* @__PURE__ */ new Set();
+ this.queuedRedirectEvent = null;
+ this.hasHandledPotentialRedirect = false;
+ this.lastProcessedEventTime = Date.now();
+ }
+ registerConsumer(authEventConsumer) {
+ this.consumers.add(authEventConsumer);
+ if (this.queuedRedirectEvent && this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)) {
+ this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer);
+ this.saveEventToCache(this.queuedRedirectEvent);
+ this.queuedRedirectEvent = null;
+ }
+ }
+ unregisterConsumer(authEventConsumer) {
+ this.consumers.delete(authEventConsumer);
+ }
+ onEvent(event) {
+ if (this.hasEventBeenHandled(event)) {
+ return false;
+ }
+ let handled = false;
+ this.consumers.forEach((consumer) => {
+ if (this.isEventForConsumer(event, consumer)) {
+ handled = true;
+ this.sendToConsumer(event, consumer);
+ this.saveEventToCache(event);
+ }
+ });
+ if (this.hasHandledPotentialRedirect || !isRedirectEvent(event)) {
+ return handled;
+ }
+ this.hasHandledPotentialRedirect = true;
+ if (!handled) {
+ this.queuedRedirectEvent = event;
+ handled = true;
+ }
+ return handled;
+ }
+ sendToConsumer(event, consumer) {
+ var _a2;
+ if (event.error && !isNullRedirectEvent(event)) {
+ const code = ((_a2 = event.error.code) === null || _a2 === void 0 ? void 0 : _a2.split("auth/")[1]) || "internal-error";
+ consumer.onError(_createError(this.auth, code));
+ } else {
+ consumer.onAuthEvent(event);
+ }
+ }
+ isEventForConsumer(event, consumer) {
+ const eventIdMatches = consumer.eventId === null || !!event.eventId && event.eventId === consumer.eventId;
+ return consumer.filter.includes(event.type) && eventIdMatches;
+ }
+ hasEventBeenHandled(event) {
+ if (Date.now() - this.lastProcessedEventTime >= EVENT_DUPLICATION_CACHE_DURATION_MS) {
+ this.cachedEventUids.clear();
+ }
+ return this.cachedEventUids.has(eventUid(event));
+ }
+ saveEventToCache(event) {
+ this.cachedEventUids.add(eventUid(event));
+ this.lastProcessedEventTime = Date.now();
+ }
+}
+function eventUid(e) {
+ return [e.type, e.eventId, e.sessionId, e.tenantId].filter((v2) => v2).join("-");
+}
+function isNullRedirectEvent({ type, error }) {
+ return type === "unknown" && (error === null || error === void 0 ? void 0 : error.code) === `auth/${"no-auth-event"}`;
+}
+function isRedirectEvent(event) {
+ switch (event.type) {
+ case "signInViaRedirect":
+ case "linkViaRedirect":
+ case "reauthViaRedirect":
+ return true;
+ case "unknown":
+ return isNullRedirectEvent(event);
+ default:
+ return false;
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _getProjectConfig(auth2, request = {}) {
+ return _performApiRequest(auth2, "GET", "/v1/projects", request);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const IP_ADDRESS_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const HTTP_REGEX = /^https?/;
+async function _validateOrigin(auth2) {
+ if (auth2.config.emulator) {
+ return;
+ }
+ const { authorizedDomains } = await _getProjectConfig(auth2);
+ for (const domain of authorizedDomains) {
+ try {
+ if (matchDomain(domain)) {
+ return;
+ }
+ } catch (_a2) {
+ }
+ }
+ _fail(auth2, "unauthorized-domain");
+}
+function matchDomain(expected) {
+ const currentUrl = _getCurrentUrl();
+ const { protocol, hostname } = new URL(currentUrl);
+ if (expected.startsWith("chrome-extension://")) {
+ const ceUrl = new URL(expected);
+ if (ceUrl.hostname === "" && hostname === "") {
+ return protocol === "chrome-extension:" && expected.replace("chrome-extension://", "") === currentUrl.replace("chrome-extension://", "");
+ }
+ return protocol === "chrome-extension:" && ceUrl.hostname === hostname;
+ }
+ if (!HTTP_REGEX.test(protocol)) {
+ return false;
+ }
+ if (IP_ADDRESS_REGEX.test(expected)) {
+ return hostname === expected;
+ }
+ const escapedDomainPattern = expected.replace(/\./g, "\\.");
+ const re = new RegExp("^(.+\\." + escapedDomainPattern + "|" + escapedDomainPattern + ")$", "i");
+ return re.test(hostname);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const NETWORK_TIMEOUT = new Delay(3e4, 6e4);
+function resetUnloadedGapiModules() {
+ const beacon = _window().___jsl;
+ if (beacon === null || beacon === void 0 ? void 0 : beacon.H) {
+ for (const hint of Object.keys(beacon.H)) {
+ beacon.H[hint].r = beacon.H[hint].r || [];
+ beacon.H[hint].L = beacon.H[hint].L || [];
+ beacon.H[hint].r = [...beacon.H[hint].L];
+ if (beacon.CP) {
+ for (let i = 0; i < beacon.CP.length; i++) {
+ beacon.CP[i] = null;
+ }
+ }
+ }
+ }
+}
+function loadGapi(auth2) {
+ return new Promise((resolve, reject) => {
+ var _a2, _b, _c2;
+ function loadGapiIframe() {
+ resetUnloadedGapiModules();
+ gapi.load("gapi.iframes", {
+ callback: () => {
+ resolve(gapi.iframes.getContext());
+ },
+ ontimeout: () => {
+ resetUnloadedGapiModules();
+ reject(_createError(auth2, "network-request-failed"));
+ },
+ timeout: NETWORK_TIMEOUT.get()
+ });
+ }
+ if ((_b = (_a2 = _window().gapi) === null || _a2 === void 0 ? void 0 : _a2.iframes) === null || _b === void 0 ? void 0 : _b.Iframe) {
+ resolve(gapi.iframes.getContext());
+ } else if (!!((_c2 = _window().gapi) === null || _c2 === void 0 ? void 0 : _c2.load)) {
+ loadGapiIframe();
+ } else {
+ const cbName = _generateCallbackName("iframefcb");
+ _window()[cbName] = () => {
+ if (!!gapi.load) {
+ loadGapiIframe();
+ } else {
+ reject(_createError(auth2, "network-request-failed"));
+ }
+ };
+ return _loadJS(`https://apis.google.com/js/api.js?onload=${cbName}`).catch((e) => reject(e));
+ }
+ }).catch((error) => {
+ cachedGApiLoader = null;
+ throw error;
+ });
+}
+let cachedGApiLoader = null;
+function _loadGapi(auth2) {
+ cachedGApiLoader = cachedGApiLoader || loadGapi(auth2);
+ return cachedGApiLoader;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const PING_TIMEOUT = new Delay(5e3, 15e3);
+const IFRAME_PATH = "__/auth/iframe";
+const EMULATED_IFRAME_PATH = "emulator/auth/iframe";
+const IFRAME_ATTRIBUTES = {
+ style: {
+ position: "absolute",
+ top: "-100px",
+ width: "1px",
+ height: "1px"
+ },
+ "aria-hidden": "true",
+ tabindex: "-1"
+};
+const EID_FROM_APIHOST = /* @__PURE__ */ new Map([
+ ["identitytoolkit.googleapis.com", "p"],
+ ["staging-identitytoolkit.sandbox.googleapis.com", "s"],
+ ["test-identitytoolkit.sandbox.googleapis.com", "t"]
+]);
+function getIframeUrl(auth2) {
+ const config = auth2.config;
+ _assert(config.authDomain, auth2, "auth-domain-config-required");
+ const url = config.emulator ? _emulatorUrl(config, EMULATED_IFRAME_PATH) : `https://${auth2.config.authDomain}/${IFRAME_PATH}`;
+ const params = {
+ apiKey: config.apiKey,
+ appName: auth2.name,
+ v: SDK_VERSION
+ };
+ const eid = EID_FROM_APIHOST.get(auth2.config.apiHost);
+ if (eid) {
+ params.eid = eid;
+ }
+ const frameworks = auth2._getFrameworks();
+ if (frameworks.length) {
+ params.fw = frameworks.join(",");
+ }
+ return `${url}?${querystring(params).slice(1)}`;
+}
+async function _openIframe(auth2) {
+ const context = await _loadGapi(auth2);
+ const gapi2 = _window().gapi;
+ _assert(gapi2, auth2, "internal-error");
+ return context.open({
+ where: document.body,
+ url: getIframeUrl(auth2),
+ messageHandlersFilter: gapi2.iframes.CROSS_ORIGIN_IFRAMES_FILTER,
+ attributes: IFRAME_ATTRIBUTES,
+ dontclear: true
+ }, (iframe) => new Promise(async (resolve, reject) => {
+ await iframe.restyle({
+ setHideOnLeave: false
+ });
+ const networkError = _createError(auth2, "network-request-failed");
+ const networkErrorTimer = _window().setTimeout(() => {
+ reject(networkError);
+ }, PING_TIMEOUT.get());
+ function clearTimerAndResolve() {
+ _window().clearTimeout(networkErrorTimer);
+ resolve(iframe);
+ }
+ iframe.ping(clearTimerAndResolve).then(clearTimerAndResolve, () => {
+ reject(networkError);
+ });
+ }));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const BASE_POPUP_OPTIONS = {
+ location: "yes",
+ resizable: "yes",
+ statusbar: "yes",
+ toolbar: "no"
+};
+const DEFAULT_WIDTH = 500;
+const DEFAULT_HEIGHT = 600;
+const TARGET_BLANK = "_blank";
+const FIREFOX_EMPTY_URL = "http://localhost";
+class AuthPopup {
+ constructor(window2) {
+ this.window = window2;
+ this.associatedEvent = null;
+ }
+ close() {
+ if (this.window) {
+ try {
+ this.window.close();
+ } catch (e) {
+ }
+ }
+ }
+}
+function _open(auth2, url, name2, width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT) {
+ const top = Math.max((window.screen.availHeight - height) / 2, 0).toString();
+ const left = Math.max((window.screen.availWidth - width) / 2, 0).toString();
+ let target = "";
+ const options = Object.assign(Object.assign({}, BASE_POPUP_OPTIONS), {
+ width: width.toString(),
+ height: height.toString(),
+ top,
+ left
+ });
+ const ua2 = getUA().toLowerCase();
+ if (name2) {
+ target = _isChromeIOS(ua2) ? TARGET_BLANK : name2;
+ }
+ if (_isFirefox(ua2)) {
+ url = url || FIREFOX_EMPTY_URL;
+ options.scrollbars = "yes";
+ }
+ const optionsString = Object.entries(options).reduce((accum, [key, value]) => `${accum}${key}=${value},`, "");
+ if (_isIOSStandalone(ua2) && target !== "_self") {
+ openAsNewWindowIOS(url || "", target);
+ return new AuthPopup(null);
+ }
+ const newWin = window.open(url || "", target, optionsString);
+ _assert(newWin, auth2, "popup-blocked");
+ try {
+ newWin.focus();
+ } catch (e) {
+ }
+ return new AuthPopup(newWin);
+}
+function openAsNewWindowIOS(url, target) {
+ const el2 = document.createElement("a");
+ el2.href = url;
+ el2.target = target;
+ const click = document.createEvent("MouseEvent");
+ click.initMouseEvent("click", true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 1, null);
+ el2.dispatchEvent(click);
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const WIDGET_PATH = "__/auth/handler";
+const EMULATOR_WIDGET_PATH = "emulator/auth/handler";
+function _getRedirectUrl(auth2, provider2, authType, redirectUrl, eventId, additionalParams) {
+ _assert(auth2.config.authDomain, auth2, "auth-domain-config-required");
+ _assert(auth2.config.apiKey, auth2, "invalid-api-key");
+ const params = {
+ apiKey: auth2.config.apiKey,
+ appName: auth2.name,
+ authType,
+ redirectUrl,
+ v: SDK_VERSION,
+ eventId
+ };
+ if (provider2 instanceof FederatedAuthProvider) {
+ provider2.setDefaultLanguage(auth2.languageCode);
+ params.providerId = provider2.providerId || "";
+ if (!isEmpty(provider2.getCustomParameters())) {
+ params.customParameters = JSON.stringify(provider2.getCustomParameters());
+ }
+ for (const [key, value] of Object.entries(additionalParams || {})) {
+ params[key] = value;
+ }
+ }
+ if (provider2 instanceof BaseOAuthProvider) {
+ const scopes = provider2.getScopes().filter((scope) => scope !== "");
+ if (scopes.length > 0) {
+ params.scopes = scopes.join(",");
+ }
+ }
+ if (auth2.tenantId) {
+ params.tid = auth2.tenantId;
+ }
+ const paramsDict = params;
+ for (const key of Object.keys(paramsDict)) {
+ if (paramsDict[key] === void 0) {
+ delete paramsDict[key];
+ }
+ }
+ return `${getHandlerBase(auth2)}?${querystring(paramsDict).slice(1)}`;
+}
+function getHandlerBase({ config }) {
+ if (!config.emulator) {
+ return `https://${config.authDomain}/${WIDGET_PATH}`;
+ }
+ return _emulatorUrl(config, EMULATOR_WIDGET_PATH);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const WEB_STORAGE_SUPPORT_KEY = "webStorageSupport";
+class BrowserPopupRedirectResolver {
+ constructor() {
+ this.eventManagers = {};
+ this.iframes = {};
+ this.originValidationPromises = {};
+ this._redirectPersistence = browserSessionPersistence;
+ this._completeRedirectFn = _getRedirectResult;
+ this._overrideRedirectResult = _overrideRedirectResult;
+ }
+ async _openPopup(auth2, provider2, authType, eventId) {
+ var _a2;
+ debugAssert((_a2 = this.eventManagers[auth2._key()]) === null || _a2 === void 0 ? void 0 : _a2.manager, "_initialize() not called before _openPopup()");
+ const url = _getRedirectUrl(auth2, provider2, authType, _getCurrentUrl(), eventId);
+ return _open(auth2, url, _generateEventId());
+ }
+ async _openRedirect(auth2, provider2, authType, eventId) {
+ await this._originValidation(auth2);
+ _setWindowLocation(_getRedirectUrl(auth2, provider2, authType, _getCurrentUrl(), eventId));
+ return new Promise(() => {
+ });
+ }
+ _initialize(auth2) {
+ const key = auth2._key();
+ if (this.eventManagers[key]) {
+ const { manager, promise: promise2 } = this.eventManagers[key];
+ if (manager) {
+ return Promise.resolve(manager);
+ } else {
+ debugAssert(promise2, "If manager is not set, promise should be");
+ return promise2;
+ }
+ }
+ const promise = this.initAndGetManager(auth2);
+ this.eventManagers[key] = { promise };
+ promise.catch(() => {
+ delete this.eventManagers[key];
+ });
+ return promise;
+ }
+ async initAndGetManager(auth2) {
+ const iframe = await _openIframe(auth2);
+ const manager = new AuthEventManager(auth2);
+ iframe.register("authEvent", (iframeEvent) => {
+ _assert(iframeEvent === null || iframeEvent === void 0 ? void 0 : iframeEvent.authEvent, auth2, "invalid-auth-event");
+ const handled = manager.onEvent(iframeEvent.authEvent);
+ return { status: handled ? "ACK" : "ERROR" };
+ }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+ this.eventManagers[auth2._key()] = { manager };
+ this.iframes[auth2._key()] = iframe;
+ return manager;
+ }
+ _isIframeWebStorageSupported(auth2, cb2) {
+ const iframe = this.iframes[auth2._key()];
+ iframe.send(WEB_STORAGE_SUPPORT_KEY, { type: WEB_STORAGE_SUPPORT_KEY }, (result) => {
+ var _a2;
+ const isSupported = (_a2 = result === null || result === void 0 ? void 0 : result[0]) === null || _a2 === void 0 ? void 0 : _a2[WEB_STORAGE_SUPPORT_KEY];
+ if (isSupported !== void 0) {
+ cb2(!!isSupported);
+ }
+ _fail(auth2, "internal-error");
+ }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+ }
+ _originValidation(auth2) {
+ const key = auth2._key();
+ if (!this.originValidationPromises[key]) {
+ this.originValidationPromises[key] = _validateOrigin(auth2);
+ }
+ return this.originValidationPromises[key];
+ }
+ get _shouldInitProactively() {
+ return _isMobileBrowser() || _isSafari() || _isIOS();
+ }
+}
+const browserPopupRedirectResolver = BrowserPopupRedirectResolver;
+var name$1 = "@firebase/auth";
+var version$1 = "0.22.0";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthInterop {
+ constructor(auth2) {
+ this.auth = auth2;
+ this.internalListeners = /* @__PURE__ */ new Map();
+ }
+ getUid() {
+ var _a2;
+ this.assertAuthConfigured();
+ return ((_a2 = this.auth.currentUser) === null || _a2 === void 0 ? void 0 : _a2.uid) || null;
+ }
+ async getToken(forceRefresh) {
+ this.assertAuthConfigured();
+ await this.auth._initializationPromise;
+ if (!this.auth.currentUser) {
+ return null;
+ }
+ const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);
+ return { accessToken };
+ }
+ addAuthTokenListener(listener) {
+ this.assertAuthConfigured();
+ if (this.internalListeners.has(listener)) {
+ return;
+ }
+ const unsubscribe = this.auth.onIdTokenChanged((user) => {
+ listener((user === null || user === void 0 ? void 0 : user.stsTokenManager.accessToken) || null);
+ });
+ this.internalListeners.set(listener, unsubscribe);
+ this.updateProactiveRefresh();
+ }
+ removeAuthTokenListener(listener) {
+ this.assertAuthConfigured();
+ const unsubscribe = this.internalListeners.get(listener);
+ if (!unsubscribe) {
+ return;
+ }
+ this.internalListeners.delete(listener);
+ unsubscribe();
+ this.updateProactiveRefresh();
+ }
+ assertAuthConfigured() {
+ _assert(this.auth._initializationPromise, "dependent-sdk-initialized-before-auth");
+ }
+ updateProactiveRefresh() {
+ if (this.internalListeners.size > 0) {
+ this.auth._startProactiveRefresh();
+ } else {
+ this.auth._stopProactiveRefresh();
+ }
+ }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function getVersionForPlatform(clientPlatform) {
+ switch (clientPlatform) {
+ case "Node":
+ return "node";
+ case "ReactNative":
+ return "rn";
+ case "Worker":
+ return "webworker";
+ case "Cordova":
+ return "cordova";
+ default:
+ return void 0;
+ }
+}
+function registerAuth(clientPlatform) {
+ _registerComponent(new Component("auth", (container, { options: deps }) => {
+ const app2 = container.getProvider("app").getImmediate();
+ const heartbeatServiceProvider = container.getProvider("heartbeat");
+ const { apiKey, authDomain } = app2.options;
+ return ((app3, heartbeatServiceProvider2) => {
+ _assert(apiKey && !apiKey.includes(":"), "invalid-api-key", { appName: app3.name });
+ _assert(!(authDomain === null || authDomain === void 0 ? void 0 : authDomain.includes(":")), "argument-error", {
+ appName: app3.name
+ });
+ const config = {
+ apiKey,
+ authDomain,
+ clientPlatform,
+ apiHost: "identitytoolkit.googleapis.com",
+ tokenApiHost: "securetoken.googleapis.com",
+ apiScheme: "https",
+ sdkClientVersion: _getClientVersion(clientPlatform)
+ };
+ const authInstance = new AuthImpl(app3, heartbeatServiceProvider2, config);
+ _initializeAuthInstance(authInstance, deps);
+ return authInstance;
+ })(app2, heartbeatServiceProvider);
+ }, "PUBLIC").setInstantiationMode("EXPLICIT").setInstanceCreatedCallback((container, _instanceIdentifier, _instance) => {
+ const authInternalProvider = container.getProvider("auth-internal");
+ authInternalProvider.initialize();
+ }));
+ _registerComponent(new Component("auth-internal", (container) => {
+ const auth2 = _castAuth(container.getProvider("auth").getImmediate());
+ return ((auth3) => new AuthInterop(auth3))(auth2);
+ }, "PRIVATE").setInstantiationMode("EXPLICIT"));
+ registerVersion(name$1, version$1, getVersionForPlatform(clientPlatform));
+ registerVersion(name$1, version$1, "esm2017");
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const DEFAULT_ID_TOKEN_MAX_AGE = 5 * 60;
+const authIdTokenMaxAge = getExperimentalSetting("authIdTokenMaxAge") || DEFAULT_ID_TOKEN_MAX_AGE;
+let lastPostedIdToken = null;
+const mintCookieFactory = (url) => async (user) => {
+ const idTokenResult = user && await user.getIdTokenResult();
+ const idTokenAge = idTokenResult && (new Date().getTime() - Date.parse(idTokenResult.issuedAtTime)) / 1e3;
+ if (idTokenAge && idTokenAge > authIdTokenMaxAge) {
+ return;
+ }
+ const idToken = idTokenResult === null || idTokenResult === void 0 ? void 0 : idTokenResult.token;
+ if (lastPostedIdToken === idToken) {
+ return;
+ }
+ lastPostedIdToken = idToken;
+ await fetch(url, {
+ method: idToken ? "POST" : "DELETE",
+ headers: idToken ? {
+ "Authorization": `Bearer ${idToken}`
+ } : {}
+ });
+};
+function getAuth(app2 = getApp()) {
+ const provider2 = _getProvider(app2, "auth");
+ if (provider2.isInitialized()) {
+ return provider2.getImmediate();
+ }
+ const auth2 = initializeAuth(app2, {
+ popupRedirectResolver: browserPopupRedirectResolver,
+ persistence: [
+ indexedDBLocalPersistence,
+ browserLocalPersistence,
+ browserSessionPersistence
+ ]
+ });
+ const authTokenSyncUrl = getExperimentalSetting("authTokenSyncURL");
+ if (authTokenSyncUrl) {
+ const mintCookie = mintCookieFactory(authTokenSyncUrl);
+ beforeAuthStateChanged(auth2, mintCookie, () => mintCookie(auth2.currentUser));
+ onIdTokenChanged(auth2, (user) => mintCookie(user));
+ }
+ const authEmulatorHost = getDefaultEmulatorHost("auth");
+ if (authEmulatorHost) {
+ connectAuthEmulator(auth2, `http://${authEmulatorHost}`);
+ }
+ return auth2;
+}
+registerAuth("Browser");
+function mistake(navigateTo2) {
+ const bug = document.createElement("div");
+ bug.innerHTML = ` Error 404: p\xE1gina no encontrada.
+ volver al Inicio
+ Salir `;
+ const salir = postForm.querySelector(".goOut");
+ salir.addEventListener("click", () => {
+ signOut(auth).then(() => {
+ navigateTo2("/");
+ }).catch(() => {
+ });
+ });
+ const buttonPost = postForm.querySelector(".post");
+ buttonPost.addEventListener("click", (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector(".areaPost");
+ const postText = textarea.value;
+ if (postText.trim() !== "") {
+ post(postText);
+ } else {
+ alert("Ingrese post");
+ }
+ textarea.value = "";
+ });
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement("div");
+ postContainer.classList.add("divPost");
+ const name2 = document.createElement("h6");
+ name2.classList.add("userName");
+ postContainer.appendChild(name2);
+ name2.innerHTML = `${info.userEmail}`;
+ const textarea = document.createElement("textarea");
+ textarea.classList.add("showPost");
+ textarea.value = info.text;
+ postContainer.setAttribute("data-id", doc.id);
+ textarea.setAttribute("readonly", true);
+ postContainer.appendChild(textarea);
+ const buttonsContainer = document.createElement("div");
+ buttonsContainer.classList.add("buttonsPost");
+ const editButton = document.createElement("button");
+ editButton.classList.add("edit");
+ editButton.textContent = "Editar";
+ editButton.addEventListener("click", () => {
+ if (editButton.textContent === "Editar") {
+ editButton.textContent = "Guardar";
+ textarea.removeAttribute("readonly");
+ } else if (editButton.textContent === "Guardar") {
+ const editedTextarea = postContainer.querySelector("textarea").value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = "Editar";
+ textarea.setAttribute("readonly", true);
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+ const deleteButton = document.createElement("button");
+ deleteButton.classList.add("delete-btn");
+ deleteButton.textContent = "Eliminar";
+ deleteButton.addEventListener("click", () => {
+ const confirmDelete = confirm("\xBFEst\xE1s seguro que deseas eliminar este post?");
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest(".divPost").remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ const likeButton = document.createElement("button");
+ likeButton.classList.add("like-btn");
+ likeButton.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+ return postForm;
+ };
+ cf(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector(".showPost");
+ textarea.removeAttribute("readonly");
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute("data-id", doc.id);
+ }
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector(".like-btn");
+ buttonLike.innerHTML = `Inicia Sesi\xF3n
+ Reg\xEDstrate
+ Reg\xEDstrate con Google
+ `;
+ const logIn = section.querySelector(".logIn");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const register = section.querySelector(".register");
+ register.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const google = section.querySelector(".google");
+ google.addEventListener("click", () => {
+ loginWithGoogle().then(() => {
+ navigateTo2("/emprende");
+ }).catch(() => {
+ });
+ });
+ return section;
+}
+function login(navigateTo2) {
+ const sectionLogin = document.createElement("section");
+ sectionLogin.classList.add("sectionLogin");
+ sectionLogin.innerHTML = `
+ \xBFNo tienes una cuenta? Reg\xEDstrate
+
+ `;
+ const checkIn = sectionLogin.querySelector(".bottomTextLogin");
+ checkIn.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const formLogin = sectionLogin.querySelector(".formInteraction");
+ formLogin.addEventListener("submit", (e) => {
+ e.preventDefault();
+ const email = sectionLogin.querySelector(".inputEmail").value;
+ const password = sectionLogin.querySelector(".inputPassword").value;
+ signIn(email, password).then(() => {
+ navigateTo2("/emprende");
+ }).catch((err) => {
+ sectionLogin.querySelector(".note1").innerHTML = `${err.message}`;
+ });
+ });
+ return sectionLogin;
+}
+function create(navigateTo2) {
+ const sectionCreate = document.createElement("div");
+ sectionCreate.classList.add("creat");
+ sectionCreate.innerHTML = `
+ \xBFYa tienes cuenta? Iniciar Sesi\xF3n
+
+ `;
+ const logIn = sectionCreate.querySelector(".bottomText");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const form = sectionCreate.querySelector(".formCreateAccount");
+ form.addEventListener("submit", (e) => {
+ e.preventDefault();
+ const email = sectionCreate.querySelector(".card1").value;
+ const password = sectionCreate.querySelector(".card2").value;
+ createUser(email, password).then(() => {
+ navigateTo2("/emprende");
+ }).catch((err) => {
+ sectionCreate.querySelector(".alerta").innerHTML = `${err.message}`;
+ });
+ });
+ return sectionCreate;
+}
+const root = document.getElementById("root");
+root.append(init());
+const routes = [
+ { path: "/", component: init },
+ { path: "/login", component: login },
+ { path: "/register", component: create },
+ { path: "/error", component: mistake },
+ { path: "/emprende", component: home }
+];
+function navigateTo(hash) {
+ const route = routes.find((routeFind) => routeFind.path === hash);
+ if (route && route.component) {
+ window.history.pushState({}, route.path, window.location.origin + route.path);
+ if (root.firstChild) {
+ root.removeChild(root.firstChild);
+ }
+ root.append(route.component(navigateTo));
+ } else {
+ navigateTo("/error");
+ }
+}
+onAuthStateChanged(auth, (user) => {
+ if (user) {
+ navigateTo("/emprende");
+ } else if (window.location.pathname === "/emprende" && user === null) {
+ navigateTo();
+ } else {
+ navigateTo(window.location.pathname);
+ }
+});
diff --git a/dist/index.html b/dist/index.html
new file mode 100644
index 00000000..c1e3e80b
--- /dev/null
+++ b/dist/index.html
@@ -0,0 +1,18 @@
+
+
+
+ Emprende.app
+ Error 404: página no encontrada.
+ volver al Inicio
+ Salir `;
+
+ const salir = postForm.querySelector('.goOut');
+ salir.addEventListener('click', () => {
+ signOut(auth).then(() => {
+ navigateTo('/');
+ }).catch(() => {
+ });
+ });
+
+ const buttonPost = postForm.querySelector('.post');
+ buttonPost.addEventListener('click', (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector('.areaPost');
+ const postText = textarea.value;
+ if (postText.trim() !== '') {
+ post(postText);
+ } else {
+ // eslint-disable-next-line no-alert
+ alert('Ingrese post');
+ }
+ textarea.value = '';
+ });
+
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement('div');
+ postContainer.classList.add('divPost');
+ const name = document.createElement('h6');
+ name.classList.add('userName');
+ postContainer.appendChild(name);
+ name.innerHTML = `${info.userEmail}`;
+
+ const textarea = document.createElement('textarea');
+ textarea.classList.add('showPost');
+ textarea.value = info.text;
+ postContainer.setAttribute('data-id', doc.id);
+ textarea.setAttribute('readonly', true);
+ postContainer.appendChild(textarea);
+
+ const buttonsContainer = document.createElement('div');
+ buttonsContainer.classList.add('buttonsPost');
+
+ const editButton = document.createElement('button');
+ editButton.classList.add('edit');
+ editButton.textContent = 'Editar';
+ editButton.addEventListener('click', () => {
+ if (editButton.textContent === 'Editar') {
+ editButton.textContent = 'Guardar';
+ textarea.removeAttribute('readonly');
+ } else if (editButton.textContent === 'Guardar') {
+ const editedTextarea = postContainer.querySelector('textarea').value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = 'Editar';
+ textarea.setAttribute('readonly', true);
+ }
+ });
+ // Se visuliza botón editar solo en el usuario logueado
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+
+ const deleteButton = document.createElement('button');
+ deleteButton.classList.add('delete-btn');
+ deleteButton.textContent = 'Eliminar';
+ deleteButton.addEventListener('click', () => {
+ // eslint-disable-next-line no-restricted-globals, no-alert
+ const confirmDelete = confirm('¿Estás seguro que deseas eliminar este post?');
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest('.divPost').remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ // Creacion de botón de like
+ const likeButton = document.createElement('button');
+ likeButton.classList.add('like-btn');
+
+ likeButton.addEventListener('click', () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+
+ return postForm;
+ };
+
+ onSnapshot(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ // Buscar el post existente por el id del documento
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector('.showPost');
+ textarea.removeAttribute('readonly');
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute('data-id', doc.id);
+ }
+ // like
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector('.like-btn');
+ buttonLike.innerHTML = `Inicia Sesión
+ Regístrate
+ Regístrate con Google
+ `;
+ const logIn = section.querySelector('.logIn');
+ logIn.addEventListener('click', () => {
+ navigateTo('/login');
+ });
+
+ const register = section.querySelector('.register');
+ register.addEventListener('click', () => {
+ navigateTo('/register');
+ });
+
+ const google = section.querySelector('.google');
+ google.addEventListener('click', () => {
+ loginWithGoogle()
+ .then(() => {
+ navigateTo('/emprende');
+ }).catch(() => {
+ });
+ });
+ return section;
+}
diff --git a/src/Components/login.js b/src/Components/login.js
new file mode 100644
index 00000000..1e8b08db
--- /dev/null
+++ b/src/Components/login.js
@@ -0,0 +1,42 @@
+import { signIn } from '../lib/auth.js';
+
+// pantalla - inicio de sesión
+export function login(navigateTo) {
+ const sectionLogin = document.createElement('section');
+ sectionLogin.classList.add('sectionLogin');
+ sectionLogin.innerHTML = `
+ ¿No tienes una cuenta? Regístrate
+
+ `;
+
+ const checkIn = sectionLogin.querySelector('.bottomTextLogin');
+ checkIn.addEventListener('click', () => {
+ navigateTo('/register');
+ });
+
+ const formLogin = sectionLogin.querySelector('.formInteraction');
+ formLogin.addEventListener('submit', (e) => {
+ e.preventDefault();
+ const email = sectionLogin.querySelector('.inputEmail').value;
+ const password = sectionLogin.querySelector('.inputPassword').value;
+ signIn(email, password)
+ .then(() => {
+ navigateTo('/emprende');
+ })
+ .catch((err) => {
+ sectionLogin.querySelector('.note1').innerHTML = `${err.message}`;
+ });
+ });
+
+ return sectionLogin;
+}
diff --git a/src/Components/mistake.js b/src/Components/mistake.js
new file mode 100644
index 00000000..4f728da1
--- /dev/null
+++ b/src/Components/mistake.js
@@ -0,0 +1,18 @@
+// pantalla - error
+function mistake(navigateTo) {
+ const bug = document.createElement('div');
+ bug.innerHTML = ` Error 404: página no encontrada.
+ volver al Inicio
+ ¿Ya tienes cuenta? Iniciar Sesión
+
+ `;
+ const logIn = sectionCreate.querySelector('.bottomText');
+ logIn.addEventListener('click', () => {
+ navigateTo('/login');
+ });
+
+ const form = sectionCreate.querySelector('.formCreateAccount');
+ form.addEventListener('submit', (e) => {
+ e.preventDefault();
+ const email = sectionCreate.querySelector('.card1').value;
+ const password = sectionCreate.querySelector('.card2').value;
+ createUser(email, password)
+ .then(() => {
+ navigateTo('/emprende');
+ })
+ .catch((err) => {
+ sectionCreate.querySelector('.alerta').innerHTML = `${err.message}`;
+ });
+ });
+ return sectionCreate;
+}
diff --git a/src/index.html b/src/index.html
index 788db3c9..31711021 100644
--- a/src/index.html
+++ b/src/index.html
@@ -2,11 +2,15 @@
Emprende.app
+ Document
+ 
+ 
+
+ `;
+ const salir = postForm.querySelector(".goOut");
+ salir.addEventListener("click", () => {
+ signOut(auth).then(() => {
+ navigateTo2("/");
+ }).catch(() => {
+ });
+ });
+ const buttonPost = postForm.querySelector(".post");
+ buttonPost.addEventListener("click", (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector(".areaPost");
+ const postText = textarea.value;
+ if (postText.trim() !== "") {
+ post(postText);
+ } else {
+ alert("Ingrese post");
+ }
+ textarea.value = "";
+ });
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement("div");
+ postContainer.classList.add("divPost");
+ const name2 = document.createElement("h6");
+ name2.classList.add("userName");
+ postContainer.appendChild(name2);
+ name2.innerHTML = `${info.userEmail}`;
+ const textarea = document.createElement("textarea");
+ textarea.classList.add("showPost");
+ textarea.value = info.text;
+ postContainer.setAttribute("data-id", doc.id);
+ textarea.setAttribute("readonly", true);
+ postContainer.appendChild(textarea);
+ const buttonsContainer = document.createElement("div");
+ buttonsContainer.classList.add("buttonsPost");
+ const editButton = document.createElement("button");
+ editButton.classList.add("edit");
+ editButton.textContent = "Editar";
+ editButton.addEventListener("click", () => {
+ if (editButton.textContent === "Editar") {
+ editButton.textContent = "Guardar";
+ textarea.removeAttribute("readonly");
+ } else if (editButton.textContent === "Guardar") {
+ const editedTextarea = postContainer.querySelector("textarea").value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = "Editar";
+ textarea.setAttribute("readonly", true);
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+ const deleteButton = document.createElement("button");
+ deleteButton.classList.add("delete-btn");
+ deleteButton.textContent = "Eliminar";
+ deleteButton.addEventListener("click", () => {
+ const confirmDelete = confirm("\xBFEst\xE1s seguro que deseas eliminar este post?");
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest(".divPost").remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ const likeButton = document.createElement("button");
+ likeButton.classList.add("like-btn");
+ likeButton.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+ return postForm;
+ };
+ cf(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector(".showPost");
+ textarea.removeAttribute("readonly");
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute("data-id", doc.id);
+ }
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector(".like-btn");
+ buttonLike.innerHTML = ` ${postInfo.likes.length}`;
+ if (buttonLike) {
+ buttonLike.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ }
+ });
+ });
+ localStorage.getItem("userId");
+ return postForm;
+}
+const provider = new GoogleAuthProvider();
+const loginWithGoogle = () => signInWithPopup(auth, provider);
+const createUser = (email, password) => createUserWithEmailAndPassword(auth, email, password);
+const signIn = (email, password) => signInWithEmailAndPassword(auth, email, password);
+function init(navigateTo2) {
+ const section = document.createElement("section");
+ section.classList.add("init");
+ section.innerHTML = `
+ 
+
+
+ 
+
+ `;
+ const logIn = section.querySelector(".logIn");
+ logIn.addEventListener("click", () => {
+ navigateTo2("/login");
+ });
+ const register = section.querySelector(".register");
+ register.addEventListener("click", () => {
+ navigateTo2("/register");
+ });
+ const google = section.querySelector(".google");
+ google.addEventListener("click", () => {
+ loginWithGoogle().then(() => {
+ navigateTo2("/emprende");
+ }).catch(() => {
+ });
+ });
+ return section;
+}
+function login(navigateTo2) {
+ const sectionLogin = document.createElement("section");
+ sectionLogin.classList.add("sectionLogin");
+ sectionLogin.innerHTML = `
+ 
+
+ `;
+ const salir = postForm.querySelector(".goOut");
+ salir.addEventListener("click", () => {
+ signOut(auth).then(() => {
+ navigateTo2("/");
+ }).catch(() => {
+ });
+ });
+ const buttonPost = postForm.querySelector(".post");
+ buttonPost.addEventListener("click", (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector(".areaPost");
+ const postText = textarea.value;
+ if (postText.trim() !== "") {
+ post(postText);
+ } else {
+ alert("Ingrese post");
+ }
+ textarea.value = "";
+ });
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement("div");
+ postContainer.classList.add("divPost");
+ const name2 = document.createElement("h6");
+ name2.classList.add("userName");
+ postContainer.appendChild(name2);
+ name2.innerHTML = `${info.userEmail}`;
+ const textarea = document.createElement("textarea");
+ textarea.classList.add("showPost");
+ textarea.value = info.text;
+ postContainer.setAttribute("data-id", doc.id);
+ textarea.setAttribute("readonly", true);
+ postContainer.appendChild(textarea);
+ const buttonsContainer = document.createElement("div");
+ buttonsContainer.classList.add("buttonsPost");
+ const editButton = document.createElement("button");
+ editButton.classList.add("edit");
+ editButton.textContent = "Editar";
+ editButton.addEventListener("click", () => {
+ if (editButton.textContent === "Editar") {
+ editButton.textContent = "Guardar";
+ textarea.removeAttribute("readonly");
+ } else if (editButton.textContent === "Guardar") {
+ const editedTextarea = postContainer.querySelector("textarea").value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = "Editar";
+ textarea.setAttribute("readonly", true);
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+ const deleteButton = document.createElement("button");
+ deleteButton.classList.add("delete-btn");
+ deleteButton.textContent = "Eliminar";
+ deleteButton.addEventListener("click", () => {
+ const confirmDelete = confirm("\xBFEst\xE1s seguro que deseas eliminar este post?");
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest(".divPost").remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ const likeButton = document.createElement("button");
+ likeButton.classList.add("like-btn");
+ likeButton.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+ return postForm;
+ };
+ cf(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector(".showPost");
+ textarea.removeAttribute("readonly");
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute("data-id", doc.id);
+ }
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector(".like-btn");
+ buttonLike.innerHTML = ` ${postInfo.likes.length}`;
+ if (buttonLike) {
+ buttonLike.addEventListener("click", () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ }
+ });
+ });
+ localStorage.getItem("userId");
+ return postForm;
+}
+const provider = new GoogleAuthProvider();
+const loginWithGoogle = () => signInWithPopup(auth, provider);
+const createUser = (email, password) => createUserWithEmailAndPassword(auth, email, password);
+const signIn = (email, password) => signInWithEmailAndPassword(auth, email, password);
+function init(navigateTo2) {
+ const section = document.createElement("section");
+ section.classList.add("init");
+ section.innerHTML = `
+ 
+ 
+
+ `;
+
+ const salir = postForm.querySelector('.goOut');
+ salir.addEventListener('click', () => {
+ signOut(auth).then(() => {
+ navigateTo('/');
+ }).catch(() => {
+ });
+ });
+
+ const buttonPost = postForm.querySelector('.post');
+ buttonPost.addEventListener('click', (e) => {
+ e.preventDefault();
+ const textarea = postForm.querySelector('.areaPost');
+ const postText = textarea.value;
+ if (postText.trim() !== '') {
+ post(postText);
+ } else {
+ // eslint-disable-next-line no-alert
+ alert('Ingrese post');
+ }
+ textarea.value = '';
+ });
+
+ const printPost = (info, doc) => {
+ const postContainer = document.createElement('div');
+ postContainer.classList.add('divPost');
+ const name = document.createElement('h6');
+ name.classList.add('userName');
+ postContainer.appendChild(name);
+ name.innerHTML = `${info.userEmail}`;
+
+ const textarea = document.createElement('textarea');
+ textarea.classList.add('showPost');
+ textarea.value = info.text;
+ postContainer.setAttribute('data-id', doc.id);
+ textarea.setAttribute('readonly', true);
+ postContainer.appendChild(textarea);
+
+ const buttonsContainer = document.createElement('div');
+ buttonsContainer.classList.add('buttonsPost');
+
+ const editButton = document.createElement('button');
+ editButton.classList.add('edit');
+ editButton.textContent = 'Editar';
+ editButton.addEventListener('click', () => {
+ if (editButton.textContent === 'Editar') {
+ editButton.textContent = 'Guardar';
+ textarea.removeAttribute('readonly');
+ } else if (editButton.textContent === 'Guardar') {
+ const editedTextarea = postContainer.querySelector('textarea').value;
+ editPost(doc.id, editedTextarea);
+ editButton.textContent = 'Editar';
+ textarea.setAttribute('readonly', true);
+ }
+ });
+ // Se visuliza botón editar solo en el usuario logueado
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(editButton);
+ }
+
+ const deleteButton = document.createElement('button');
+ deleteButton.classList.add('delete-btn');
+ deleteButton.textContent = 'Eliminar';
+ deleteButton.addEventListener('click', () => {
+ // eslint-disable-next-line no-restricted-globals, no-alert
+ const confirmDelete = confirm('¿Estás seguro que deseas eliminar este post?');
+ if (confirmDelete) {
+ deleteDocData(doc.id);
+ deleteButton.value = doc.id;
+ deleteButton.closest('.divPost').remove();
+ }
+ });
+ if (auth.currentUser.email === info.userEmail) {
+ buttonsContainer.appendChild(deleteButton);
+ }
+ // Creacion de botón de like
+ const likeButton = document.createElement('button');
+ likeButton.classList.add('like-btn');
+
+ likeButton.addEventListener('click', () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+
+ buttonsContainer.appendChild(likeButton);
+ postContainer.appendChild(buttonsContainer);
+ postForm.appendChild(postContainer);
+
+ return postForm;
+ };
+
+ onSnapshot(ref(), (querySnapshot) => {
+ querySnapshot.forEach((doc) => {
+ const postInfo = doc.data();
+ // Buscar el post existente por el id del documento
+ const postExists = postForm.querySelector(`div[data-id="${doc.id}"]`);
+ if (postExists) {
+ const textarea = document.querySelector('.showPost');
+ textarea.removeAttribute('readonly');
+ } else {
+ const nodoP = printPost(postInfo, doc);
+ nodoP.setAttribute('data-id', doc.id);
+ }
+ // like
+ const buttonLike = postForm.querySelector(`div[data-id="${doc.id}"]`).querySelector('.like-btn');
+ buttonLike.innerHTML = ` ${postInfo.likes.length}`;
+ if (buttonLike) {
+ buttonLike.addEventListener('click', () => {
+ if (doc.data().likes.includes(auth.currentUser.email)) {
+ disLike(doc.id, auth.currentUser.email);
+ } else {
+ like(doc.id, auth.currentUser.email);
+ }
+ });
+ }
+ });
+ });
+
+ localStorage.getItem('userId');
+ return postForm;
+}
+
+export { home };
diff --git a/src/Components/init.js b/src/Components/init.js
new file mode 100644
index 00000000..3523ce81
--- /dev/null
+++ b/src/Components/init.js
@@ -0,0 +1,33 @@
+import { loginWithGoogle } from '../lib/auth';
+
+// pantalla inicial
+export function init(navigateTo) {
+ const section = document.createElement('section');
+ section.classList.add('init');
+ section.innerHTML = `
+ 
+
+ `;
+ const logIn = section.querySelector('.logIn');
+ logIn.addEventListener('click', () => {
+ navigateTo('/login');
+ });
+
+ const register = section.querySelector('.register');
+ register.addEventListener('click', () => {
+ navigateTo('/register');
+ });
+
+ const google = section.querySelector('.google');
+ google.addEventListener('click', () => {
+ loginWithGoogle()
+ .then(() => {
+ navigateTo('/emprende');
+ }).catch(() => {
+ });
+ });
+ return section;
+}
diff --git a/src/Components/login.js b/src/Components/login.js
new file mode 100644
index 00000000..1e8b08db
--- /dev/null
+++ b/src/Components/login.js
@@ -0,0 +1,42 @@
+import { signIn } from '../lib/auth.js';
+
+// pantalla - inicio de sesión
+export function login(navigateTo) {
+ const sectionLogin = document.createElement('section');
+ sectionLogin.classList.add('sectionLogin');
+ sectionLogin.innerHTML = `
+ 
+