summaryrefslogtreecommitdiff
path: root/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js
diff options
context:
space:
mode:
Diffstat (limited to 'frontend-old/node_modules/@firebase/auth/dist/rn/internal.js')
-rw-r--r--frontend-old/node_modules/@firebase/auth/dist/rn/internal.js3266
1 files changed, 3266 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js b/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js
new file mode 100644
index 0000000..e82ff87
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/rn/internal.js
@@ -0,0 +1,3266 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./index-1cf32ad3.js');
+var app = require('@firebase/app');
+var util = require('@firebase/util');
+require('@firebase/component');
+require('@firebase/logger');
+
+/**
+ * @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.
+ */
+// There are two different browser persistence types: local and session.
+// Both have the same implementation but use a different underlying storage
+// object.
+class BrowserPersistenceClass {
+ constructor(storageRetriever, type) {
+ this.storageRetriever = storageRetriever;
+ this.type = type;
+ }
+ _isAvailable() {
+ try {
+ if (!this.storage) {
+ return Promise.resolve(false);
+ }
+ this.storage.setItem(index.STORAGE_AVAILABLE_KEY, '1');
+ this.storage.removeItem(index.STORAGE_AVAILABLE_KEY);
+ return Promise.resolve(true);
+ }
+ catch {
+ 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.
+ */
+// The polling period in case events are not supported
+const _POLLING_INTERVAL_MS$1 = 1000;
+// The IE 10 localStorage cross tab synchronization delay in milliseconds
+const IE10_LOCAL_STORAGE_SYNC_DELAY = 10;
+class BrowserLocalPersistence extends BrowserPersistenceClass {
+ constructor() {
+ super(() => window.localStorage, "LOCAL" /* PersistenceType.LOCAL */);
+ this.boundEventHandler = (event, poll) => this.onStorageEvent(event, poll);
+ this.listeners = {};
+ this.localCache = {};
+ // setTimeout return value is platform specific
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ this.pollTimer = null;
+ // Whether to use polling instead of depending on window events
+ this.fallbackToPolling = index._isMobileBrowser();
+ this._shouldAllowMigration = true;
+ }
+ forAllChangedKeys(cb) {
+ // Check all keys with listeners on them.
+ for (const key of Object.keys(this.listeners)) {
+ // Get value from localStorage.
+ const newValue = this.storage.getItem(key);
+ const oldValue = this.localCache[key];
+ // If local map value does not match, trigger listener with storage event.
+ // Differentiate this simulated event from the real storage event.
+ if (newValue !== oldValue) {
+ cb(key, oldValue, newValue);
+ }
+ }
+ }
+ onStorageEvent(event, poll = false) {
+ // Key would be null in some situations, like when localStorage is cleared
+ if (!event.key) {
+ this.forAllChangedKeys((key, _oldValue, newValue) => {
+ this.notifyListeners(key, newValue);
+ });
+ return;
+ }
+ const key = event.key;
+ // Check the mechanism how this event was detected.
+ // The first event will dictate the mechanism to be used.
+ if (poll) {
+ // Environment detects storage changes via polling.
+ // Remove storage event listener to prevent possible event duplication.
+ this.detachListener();
+ }
+ else {
+ // Environment detects storage changes via storage event listener.
+ // Remove polling listener to prevent possible event duplication.
+ this.stopPolling();
+ }
+ const triggerListeners = () => {
+ // Keep local map up to date in case storage event is triggered before
+ // poll.
+ const storedValue = this.storage.getItem(key);
+ if (!poll && this.localCache[key] === storedValue) {
+ // Real storage event which has already been detected, do nothing.
+ // This seems to trigger in some IE browsers for some reason.
+ return;
+ }
+ this.notifyListeners(key, storedValue);
+ };
+ const storedValue = this.storage.getItem(key);
+ if (index._isIE10() &&
+ storedValue !== event.newValue &&
+ event.newValue !== event.oldValue) {
+ // IE 10 has this weird bug where a storage event would trigger with the
+ // correct key, oldValue and newValue but localStorage.getItem(key) does
+ // not yield the updated value until a few milliseconds. This ensures
+ // this recovers from that situation.
+ 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
+ }),
+ /* poll */ 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) {
+ // Whether browser can detect storage event when it had already been pushed to the background.
+ // This may happen in some mobile browsers. A localStorage change in the foreground window
+ // will not be detected in the background window via the storage event.
+ // This was detected in iOS 7.x mobile browsers
+ if (this.fallbackToPolling) {
+ this.startPolling();
+ }
+ else {
+ this.attachListener();
+ }
+ }
+ if (!this.listeners[key]) {
+ this.listeners[key] = new Set();
+ // Populate the cache to avoid spuriously triggering on first poll.
+ 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();
+ }
+ }
+ // Update local cache on base operations:
+ 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';
+/**
+ * An implementation of {@link Persistence} of type `LOCAL` using `localStorage`
+ * for the underlying storage.
+ *
+ * @public
+ */
+const browserLocalPersistence = BrowserLocalPersistence;
+
+/**
+ * @license
+ * Copyright 2025 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 POLLING_INTERVAL_MS = 1000;
+// Pull a cookie value from document.cookie
+function getDocumentCookie(name) {
+ const escapedName = name.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+ const matcher = RegExp(`${escapedName}=([^;]+)`);
+ return document.cookie.match(matcher)?.[1] ?? null;
+}
+// Produce a sanitized cookie name from the persistence key
+function getCookieName(key) {
+ // __HOST- doesn't work in localhost https://issues.chromium.org/issues/40196122 but it has
+ // desirable security properties, so lets use a different cookie name while in dev-mode.
+ // Already checked isSecureContext in _isAvailable, so if it's http we're hitting local.
+ const isDevMode = window.location.protocol === 'http:';
+ return `${isDevMode ? '__dev_' : '__HOST-'}FIREBASE_${key.split(':')[3]}`;
+}
+class CookiePersistence {
+ constructor() {
+ this.type = "COOKIE" /* PersistenceType.COOKIE */;
+ this.listenerUnsubscribes = new Map();
+ }
+ // used to get the URL to the backend to proxy to
+ _getFinalTarget(originalUrl) {
+ if (typeof window === undefined) {
+ return originalUrl;
+ }
+ const url = new URL(`${window.location.origin}/__cookies__`);
+ url.searchParams.set('finalTarget', originalUrl);
+ return url;
+ }
+ // To be a usable persistence method in a chain browserCookiePersistence ensures that
+ // prerequisites have been met, namely that we're in a secureContext, navigator and document are
+ // available and cookies are enabled. Not all UAs support these method, so fallback accordingly.
+ async _isAvailable() {
+ if (typeof isSecureContext === 'boolean' && !isSecureContext) {
+ return false;
+ }
+ if (typeof navigator === 'undefined' || typeof document === 'undefined') {
+ return false;
+ }
+ return navigator.cookieEnabled ?? true;
+ }
+ // Set should be a noop as we expect middleware to handle this
+ async _set(_key, _value) {
+ return;
+ }
+ // Attempt to get the cookie from cookieStore, fallback to document.cookie
+ async _get(key) {
+ if (!this._isAvailable()) {
+ return null;
+ }
+ const name = getCookieName(key);
+ if (window.cookieStore) {
+ const cookie = await window.cookieStore.get(name);
+ return cookie?.value;
+ }
+ return getDocumentCookie(name);
+ }
+ // Log out by overriding the idToken with a sentinel value of ""
+ async _remove(key) {
+ if (!this._isAvailable()) {
+ return;
+ }
+ // To make sure we don't hit signout over and over again, only do this operation if we need to
+ // with the logout sentinel value of "" this can cause race conditions. Unnecessary set-cookie
+ // headers will reduce CDN hit rates too.
+ const existingValue = await this._get(key);
+ if (!existingValue) {
+ return;
+ }
+ const name = getCookieName(key);
+ document.cookie = `${name}=;Max-Age=34560000;Partitioned;Secure;SameSite=Strict;Path=/;Priority=High`;
+ await fetch(`/__cookies__`, { method: 'DELETE' }).catch(() => undefined);
+ }
+ // Listen for cookie changes, both cookieStore and fallback to polling document.cookie
+ _addListener(key, listener) {
+ if (!this._isAvailable()) {
+ return;
+ }
+ const name = getCookieName(key);
+ if (window.cookieStore) {
+ const cb = ((event) => {
+ const changedCookie = event.changed.find(change => change.name === name);
+ if (changedCookie) {
+ listener(changedCookie.value);
+ }
+ const deletedCookie = event.deleted.find(change => change.name === name);
+ if (deletedCookie) {
+ listener(null);
+ }
+ });
+ const unsubscribe = () => window.cookieStore.removeEventListener('change', cb);
+ this.listenerUnsubscribes.set(listener, unsubscribe);
+ return window.cookieStore.addEventListener('change', cb);
+ }
+ let lastValue = getDocumentCookie(name);
+ const interval = setInterval(() => {
+ const currentValue = getDocumentCookie(name);
+ if (currentValue !== lastValue) {
+ listener(currentValue);
+ lastValue = currentValue;
+ }
+ }, POLLING_INTERVAL_MS);
+ const unsubscribe = () => clearInterval(interval);
+ this.listenerUnsubscribes.set(listener, unsubscribe);
+ }
+ _removeListener(_key, listener) {
+ const unsubscribe = this.listenerUnsubscribes.get(listener);
+ if (!unsubscribe) {
+ return;
+ }
+ unsubscribe();
+ this.listenerUnsubscribes.delete(listener);
+ }
+}
+CookiePersistence.type = 'COOKIE';
+/**
+ * An implementation of {@link Persistence} of type `COOKIE`, for use on the client side in
+ * applications leveraging hybrid rendering and middleware.
+ *
+ * @remarks This persistence method requires companion middleware to function, such as that provided
+ * by {@link https://firebaseopensource.com/projects/firebaseextended/reactfire/ | ReactFire} for
+ * NextJS.
+ * @beta
+ */
+const browserCookiePersistence = CookiePersistence;
+
+/**
+ * @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" /* PersistenceType.SESSION */);
+ }
+ _addListener(_key, _listener) {
+ // Listeners are not supported for session storage since it cannot be shared across windows
+ return;
+ }
+ _removeListener(_key, _listener) {
+ // Listeners are not supported for session storage since it cannot be shared across windows
+ return;
+ }
+}
+BrowserSessionPersistence.type = 'SESSION';
+/**
+ * An implementation of {@link Persistence} of `SESSION` using `sessionStorage`
+ * for the underlying storage.
+ *
+ * @public
+ */
+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.
+ */
+/**
+ * Shim for Promise.allSettled, note the slightly different format of `fulfilled` vs `status`.
+ *
+ * @param promises - Array of promises to wait on.
+ */
+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.
+ */
+/**
+ * Interface class for receiving messages.
+ *
+ */
+class Receiver {
+ constructor(eventTarget) {
+ this.eventTarget = eventTarget;
+ this.handlersMap = {};
+ this.boundEventHandler = this.handleEvent.bind(this);
+ }
+ /**
+ * Obtain an instance of a Receiver for a given event target, if none exists it will be created.
+ *
+ * @param eventTarget - An event target (such as window or self) through which the underlying
+ * messages will be received.
+ */
+ static _getInstance(eventTarget) {
+ // The results are stored in an array since objects can't be keys for other
+ // objects. In addition, setting a unique property on an event target as a
+ // hash map key may not be allowed due to CORS restrictions.
+ 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;
+ }
+ /**
+ * Fans out a MessageEvent to the appropriate listeners.
+ *
+ * @remarks
+ * Sends an {@link Status.ACK} upon receipt and a {@link Status.DONE} once all handlers have
+ * finished processing.
+ *
+ * @param event - The MessageEvent.
+ *
+ */
+ async handleEvent(event) {
+ const messageEvent = event;
+ const { eventId, eventType, data } = messageEvent.data;
+ const handlers = this.handlersMap[eventType];
+ if (!handlers?.size) {
+ return;
+ }
+ messageEvent.ports[0].postMessage({
+ status: "ack" /* _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" /* _Status.DONE */,
+ eventId,
+ eventType,
+ response
+ });
+ }
+ /**
+ * Subscribe an event handler for a particular event.
+ *
+ * @param eventType - Event name to subscribe to.
+ * @param eventHandler - The event handler which should receive the events.
+ *
+ */
+ _subscribe(eventType, eventHandler) {
+ if (Object.keys(this.handlersMap).length === 0) {
+ this.eventTarget.addEventListener('message', this.boundEventHandler);
+ }
+ if (!this.handlersMap[eventType]) {
+ this.handlersMap[eventType] = new Set();
+ }
+ this.handlersMap[eventType].add(eventHandler);
+ }
+ /**
+ * Unsubscribe an event handler from a particular event.
+ *
+ * @param eventType - Event name to unsubscribe from.
+ * @param eventHandler - Optional event handler, if none provided, unsubscribe all handlers on this event.
+ *
+ */
+ _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.
+ */
+/**
+ * Interface for sending messages and waiting for a completion response.
+ *
+ */
+class Sender {
+ constructor(target) {
+ this.target = target;
+ this.handlers = new Set();
+ }
+ /**
+ * Unsubscribe the handler and remove it from our tracking Set.
+ *
+ * @param handler - The handler to unsubscribe.
+ */
+ removeMessageHandler(handler) {
+ if (handler.messageChannel) {
+ handler.messageChannel.port1.removeEventListener('message', handler.onMessage);
+ handler.messageChannel.port1.close();
+ }
+ this.handlers.delete(handler);
+ }
+ /**
+ * Send a message to the Receiver located at {@link target}.
+ *
+ * @remarks
+ * We'll first wait a bit for an ACK , if we get one we will wait significantly longer until the
+ * receiver has had a chance to fully process the event.
+ *
+ * @param eventType - Type of event to send.
+ * @param data - The payload of the event.
+ * @param timeout - Timeout for waiting on an ACK from the receiver.
+ *
+ * @returns An array of settled promises from all the handlers that were listening on the receiver.
+ */
+ async _send(eventType, data, timeout = 50 /* _TimeoutDuration.ACK */) {
+ const messageChannel = typeof MessageChannel !== 'undefined' ? new MessageChannel() : null;
+ if (!messageChannel) {
+ throw new Error("connection_unavailable" /* _MessageError.CONNECTION_UNAVAILABLE */);
+ }
+ // Node timers and browser timers return fundamentally different types.
+ // We don't actually care what the value is but TS won't accept unknown and
+ // we can't cast properly in both environments.
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ let completionTimer;
+ let handler;
+ return new Promise((resolve, reject) => {
+ const eventId = _generateEventId('', 20);
+ messageChannel.port1.start();
+ const ackTimer = setTimeout(() => {
+ reject(new Error("unsupported_event" /* _MessageError.UNSUPPORTED_EVENT */));
+ }, timeout);
+ handler = {
+ messageChannel,
+ onMessage(event) {
+ const messageEvent = event;
+ if (messageEvent.data.eventId !== eventId) {
+ return;
+ }
+ switch (messageEvent.data.status) {
+ case "ack" /* _Status.ACK */:
+ // The receiver should ACK first.
+ clearTimeout(ackTimer);
+ completionTimer = setTimeout(() => {
+ reject(new Error("timeout" /* _MessageError.TIMEOUT */));
+ }, 3000 /* _TimeoutDuration.COMPLETION */);
+ break;
+ case "done" /* _Status.DONE */:
+ // Once the receiver's handlers are finished we will get the results.
+ clearTimeout(completionTimer);
+ resolve(messageEvent.data.response);
+ break;
+ default:
+ clearTimeout(ackTimer);
+ clearTimeout(completionTimer);
+ reject(new Error("invalid_response" /* _MessageError.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 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';
+/**
+ * Promise wrapper for IDBRequest
+ *
+ * Unfortunately we can't cleanly extend Promise<T> since promises are not callable in ES6
+ *
+ */
+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(db, isReadWrite) {
+ return db
+ .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 db = request.result;
+ try {
+ db.createObjectStore(DB_OBJECTSTORE_NAME, { keyPath: DB_DATA_KEYPATH });
+ }
+ catch (e) {
+ reject(e);
+ }
+ });
+ request.addEventListener('success', async () => {
+ const db = request.result;
+ // Strange bug that occurs in Firefox when multiple tabs are opened at the
+ // same time. The only way to recover seems to be deleting the database
+ // and re-initializing it.
+ // https://github.com/firebase/firebase-js-sdk/issues/634
+ if (!db.objectStoreNames.contains(DB_OBJECTSTORE_NAME)) {
+ // Need to close the database or else you get a `blocked` event
+ db.close();
+ await _deleteDatabase();
+ resolve(await _openDatabase());
+ }
+ else {
+ resolve(db);
+ }
+ });
+ });
+}
+async function _putObject(db, key, value) {
+ const request = getObjectStore(db, true).put({
+ [DB_DATA_KEYPATH]: key,
+ value
+ });
+ return new DBPromise(request).toPromise();
+}
+async function getObject(db, key) {
+ const request = getObjectStore(db, false).get(key);
+ const data = await new DBPromise(request).toPromise();
+ return data === undefined ? null : data.value;
+}
+function _deleteObject(db, key) {
+ const request = getObjectStore(db, true).delete(key);
+ return new DBPromise(request).toPromise();
+}
+const _POLLING_INTERVAL_MS = 800;
+const _TRANSACTION_RETRY_COUNT = 3;
+class IndexedDBLocalPersistence {
+ constructor() {
+ this.type = "LOCAL" /* PersistenceType.LOCAL */;
+ this._shouldAllowMigration = true;
+ this.listeners = {};
+ this.localCache = {};
+ // setTimeout return value is platform specific
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ this.pollTimer = null;
+ this.pendingWrites = 0;
+ this.receiver = null;
+ this.sender = null;
+ this.serviceWorkerReceiverAvailable = false;
+ this.activeServiceWorker = null;
+ // Fire & forget the service worker registration as it may never resolve
+ 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 db = await this._openDb();
+ return await op(db);
+ }
+ catch (e) {
+ if (numAttempts++ > _TRANSACTION_RETRY_COUNT) {
+ throw e;
+ }
+ if (this.db) {
+ this.db.close();
+ this.db = undefined;
+ }
+ // TODO: consider adding exponential backoff
+ }
+ }
+ }
+ /**
+ * IndexedDB events do not propagate from the main window to the worker context. We rely on a
+ * postMessage interface to send these events to the worker ourselves.
+ */
+ async initializeServiceWorkerMessaging() {
+ return index._isWorker() ? this.initializeReceiver() : this.initializeSender();
+ }
+ /**
+ * As the worker we should listen to events from the main window.
+ */
+ async initializeReceiver() {
+ this.receiver = Receiver._getInstance(index._getWorkerGlobalScope());
+ // Refresh from persistence if we receive a KeyChanged message.
+ this.receiver._subscribe("keyChanged" /* _EventType.KEY_CHANGED */, async (_origin, data) => {
+ const keys = await this._poll();
+ return {
+ keyProcessed: keys.includes(data.key)
+ };
+ });
+ // Let the sender know that we are listening so they give us more timeout.
+ this.receiver._subscribe("ping" /* _EventType.PING */, async (_origin, _data) => {
+ return ["keyChanged" /* _EventType.KEY_CHANGED */];
+ });
+ }
+ /**
+ * As the main window, we should let the worker know when keys change (set and remove).
+ *
+ * @remarks
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/ready | ServiceWorkerContainer.ready}
+ * may not resolve.
+ */
+ async initializeSender() {
+ // Check to see if there's an active service worker.
+ this.activeServiceWorker = await index._getActiveServiceWorker();
+ if (!this.activeServiceWorker) {
+ return;
+ }
+ this.sender = new Sender(this.activeServiceWorker);
+ // Ping the service worker to check what events they can handle.
+ const results = await this.sender._send("ping" /* _EventType.PING */, {}, 800 /* _TimeoutDuration.LONG_ACK */);
+ if (!results) {
+ return;
+ }
+ if (results[0]?.fulfilled &&
+ results[0]?.value.includes("keyChanged" /* _EventType.KEY_CHANGED */)) {
+ this.serviceWorkerReceiverAvailable = true;
+ }
+ }
+ /**
+ * Let the worker know about a changed key, the exact key doesn't technically matter since the
+ * worker will just trigger a full sync anyway.
+ *
+ * @remarks
+ * For now, we only support one service worker per page.
+ *
+ * @param key - Storage key which changed.
+ */
+ async notifyServiceWorker(key) {
+ if (!this.sender ||
+ !this.activeServiceWorker ||
+ index._getServiceWorkerController() !== this.activeServiceWorker) {
+ return;
+ }
+ try {
+ await this.sender._send("keyChanged" /* _EventType.KEY_CHANGED */, { key },
+ // Use long timeout if receiver has previously responded to a ping from us.
+ this.serviceWorkerReceiverAvailable
+ ? 800 /* _TimeoutDuration.LONG_ACK */
+ : 50 /* _TimeoutDuration.ACK */);
+ }
+ catch {
+ // This is a best effort approach. Ignore errors.
+ }
+ }
+ async _isAvailable() {
+ try {
+ if (!indexedDB) {
+ return false;
+ }
+ const db = await _openDatabase();
+ await _putObject(db, index.STORAGE_AVAILABLE_KEY, '1');
+ await _deleteObject(db, index.STORAGE_AVAILABLE_KEY);
+ return true;
+ }
+ catch { }
+ return false;
+ }
+ async _withPendingWrite(write) {
+ this.pendingWrites++;
+ try {
+ await write();
+ }
+ finally {
+ this.pendingWrites--;
+ }
+ }
+ async _set(key, value) {
+ return this._withPendingWrite(async () => {
+ await this._withRetries((db) => _putObject(db, key, value));
+ this.localCache[key] = value;
+ return this.notifyServiceWorker(key);
+ });
+ }
+ async _get(key) {
+ const obj = (await this._withRetries((db) => getObject(db, key)));
+ this.localCache[key] = obj;
+ return obj;
+ }
+ async _remove(key) {
+ return this._withPendingWrite(async () => {
+ await this._withRetries((db) => _deleteObject(db, key));
+ delete this.localCache[key];
+ return this.notifyServiceWorker(key);
+ });
+ }
+ async _poll() {
+ // TODO: check if we need to fallback if getAll is not supported
+ const result = await this._withRetries((db) => {
+ const getAllRequest = getObjectStore(db, false).getAll();
+ return new DBPromise(getAllRequest).toPromise();
+ });
+ if (!result) {
+ return [];
+ }
+ // If we have pending writes in progress abort, we'll get picked up on the next poll
+ if (this.pendingWrites !== 0) {
+ return [];
+ }
+ const keys = [];
+ const keysInResult = new Set();
+ if (result.length !== 0) {
+ 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)) {
+ // Deleted
+ 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] = new Set();
+ // Populate the cache to avoid spuriously triggering on first poll.
+ void this._get(key); // This can happen in the background async and we can return immediately.
+ }
+ 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';
+/**
+ * An implementation of {@link Persistence} of type `LOCAL` using `indexedDB`
+ * for the underlying storage.
+ *
+ * @public
+ */
+const indexedDBLocalPersistence = IndexedDBLocalPersistence;
+
+/**
+ * @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.
+ */
+/**
+ * Chooses a popup/redirect resolver to use. This prefers the override (which
+ * is directly passed in), and falls back to the property set on the auth
+ * object. If neither are available, this function errors w/ an argument error.
+ */
+function _withDefaultResolver(auth, resolverOverride) {
+ if (resolverOverride) {
+ return index._getInstance(resolverOverride);
+ }
+ index._assert(auth._popupRedirectResolver, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+ return auth._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 index.AuthCredential {
+ constructor(params) {
+ super("custom" /* ProviderId.CUSTOM */, "custom" /* ProviderId.CUSTOM */);
+ this.params = params;
+ }
+ _getIdTokenResponse(auth) {
+ return index.signInWithIdp(auth, this._buildIdpRequest());
+ }
+ _linkToIdToken(auth, idToken) {
+ return index.signInWithIdp(auth, this._buildIdpRequest(idToken));
+ }
+ _getReauthenticationResolver(auth) {
+ return index.signInWithIdp(auth, 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 index._signInWithCredential(params.auth, new IdpCredential(params), params.bypassAuthState);
+}
+function _reauth(params) {
+ const { auth, user } = params;
+ index._assert(user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ return index._reauthenticate(user, new IdpCredential(params), params.bypassAuthState);
+}
+async function _link(params) {
+ const { auth, user } = params;
+ index._assert(user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ return index._link(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.
+ */
+/**
+ * Popup event manager. Handles the popup's entire lifecycle; listens to auth
+ * events
+ */
+class AbstractPopupRedirectOperation {
+ constructor(auth, filter, resolver, user, bypassAuthState = false) {
+ this.auth = auth;
+ 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: sessionId,
+ tenantId: tenantId || undefined,
+ postBody: postBody || undefined,
+ 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" /* AuthEventType.SIGN_IN_VIA_POPUP */:
+ case "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */:
+ return _signIn;
+ case "linkViaPopup" /* AuthEventType.LINK_VIA_POPUP */:
+ case "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */:
+ return _link;
+ case "reauthViaPopup" /* AuthEventType.REAUTH_VIA_POPUP */:
+ case "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */:
+ return _reauth;
+ default:
+ index._fail(this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ }
+ }
+ resolve(cred) {
+ index.debugAssert(this.pendingPromise, 'Pending promise was never set');
+ this.pendingPromise.resolve(cred);
+ this.unregisterAndCleanUp();
+ }
+ reject(error) {
+ index.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 index.Delay(2000, 10000);
+/**
+ * Authenticates a Firebase client using a popup-based OAuth authentication flow.
+ *
+ * @remarks
+ * If succeeds, returns the signed in user along with the provider's credential. If sign in was
+ * unsuccessful, returns an error object containing additional information about the error.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new FacebookAuthProvider();
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a Facebook Access Token.
+ * const credential = provider.credentialFromResult(auth, result);
+ * const token = credential.accessToken;
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+async function signInWithPopup(auth, provider, resolver) {
+ if (app._isFirebaseServerApp(auth.app)) {
+ return Promise.reject(index._createError(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */));
+ }
+ const authInternal = index._castAuth(auth);
+ index._assertInstanceOf(auth, provider, index.FederatedAuthProvider);
+ const resolverInternal = _withDefaultResolver(authInternal, resolver);
+ const action = new PopupOperation(authInternal, "signInViaPopup" /* AuthEventType.SIGN_IN_VIA_POPUP */, provider, resolverInternal);
+ return action.executeNotNull();
+}
+/**
+ * Reauthenticates the current user with the specified {@link OAuthProvider} using a pop-up based
+ * OAuth flow.
+ *
+ * @remarks
+ * If the reauthentication is successful, the returned result will contain the user and the
+ * provider's credential.
+ *
+ * This method does not work in a Node.js environment or on any {@link User} signed in by
+ * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new FacebookAuthProvider();
+ * const result = await signInWithPopup(auth, provider);
+ * // Reauthenticate using a popup.
+ * await reauthenticateWithPopup(result.user, provider);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+async function reauthenticateWithPopup(user, provider, resolver) {
+ const userInternal = util.getModularInstance(user);
+ if (app._isFirebaseServerApp(userInternal.auth.app)) {
+ return Promise.reject(index._createError(userInternal.auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */));
+ }
+ index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider);
+ const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
+ const action = new PopupOperation(userInternal.auth, "reauthViaPopup" /* AuthEventType.REAUTH_VIA_POPUP */, provider, resolverInternal, userInternal);
+ return action.executeNotNull();
+}
+/**
+ * Links the authenticated provider to the user account using a pop-up based OAuth flow.
+ *
+ * @remarks
+ * If the linking is successful, the returned result will contain the user and the provider's credential.
+ *
+ * This method does not work in a Node.js environment.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using some other provider.
+ * const result = await signInWithEmailAndPassword(auth, email, password);
+ * // Link using a popup.
+ * const provider = new FacebookAuthProvider();
+ * await linkWithPopup(result.user, provider);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+async function linkWithPopup(user, provider, resolver) {
+ const userInternal = util.getModularInstance(user);
+ index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider);
+ const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
+ const action = new PopupOperation(userInternal.auth, "linkViaPopup" /* AuthEventType.LINK_VIA_POPUP */, provider, resolverInternal, userInternal);
+ return action.executeNotNull();
+}
+/**
+ * Popup event manager. Handles the popup's entire lifecycle; listens to auth
+ * events
+ *
+ */
+class PopupOperation extends AbstractPopupRedirectOperation {
+ constructor(auth, filter, provider, resolver, user) {
+ super(auth, filter, resolver, user);
+ this.provider = provider;
+ this.authWindow = null;
+ this.pollId = null;
+ if (PopupOperation.currentPopupAction) {
+ PopupOperation.currentPopupAction.cancel();
+ }
+ PopupOperation.currentPopupAction = this;
+ }
+ async executeNotNull() {
+ const result = await this.execute();
+ index._assert(result, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ return result;
+ }
+ async onExecution() {
+ index.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], // There's always one, see constructor
+ eventId);
+ this.authWindow.associatedEvent = eventId;
+ // Check for web storage support and origin validation _after_ the popup is
+ // loaded. These operations are slow (~1 second or so) Rather than
+ // waiting on them before opening the window, optimistically open the popup
+ // and check for storage support at the same time. If storage support is
+ // not available, this will cause the whole thing to reject properly. It
+ // will also close the popup, but since the promise has already rejected,
+ // the popup closed by user poll will reject into the void.
+ this.resolver._originValidation(this.auth).catch(e => {
+ this.reject(e);
+ });
+ this.resolver._isIframeWebStorageSupported(this.auth, isSupported => {
+ if (!isSupported) {
+ this.reject(index._createError(this.auth, "web-storage-unsupported" /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */));
+ }
+ });
+ // Handle user closure. Notice this does *not* use await
+ this.pollUserCancellation();
+ }
+ get eventId() {
+ return this.authWindow?.associatedEvent || null;
+ }
+ cancel() {
+ this.reject(index._createError(this.auth, "cancelled-popup-request" /* AuthErrorCode.EXPIRED_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 = () => {
+ if (this.authWindow?.window?.closed) {
+ // Make sure that there is sufficient time for whatever action to
+ // complete. The window could have closed but the sign in network
+ // call could still be in flight. This is specifically true for
+ // Firefox or if the opener is in an iframe, in which case the oauth
+ // helper closes the popup.
+ this.pollId = window.setTimeout(() => {
+ this.pollId = null;
+ this.reject(index._createError(this.auth, "popup-closed-by-user" /* AuthErrorCode.POPUP_CLOSED_BY_USER */));
+ }, 8000 /* _Timeout.AUTH_EVENT */);
+ return;
+ }
+ this.pollId = window.setTimeout(poll, _POLL_WINDOW_CLOSE_TIMEOUT.get());
+ };
+ poll();
+ }
+}
+// Only one popup is ever shown at once. The lifecycle of the current popup
+// can be managed / cancelled by the constructor.
+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';
+// We only get one redirect outcome for any one auth, so just store it
+// in here.
+const redirectOutcomeMap = new Map();
+class RedirectAction extends AbstractPopupRedirectOperation {
+ constructor(auth, resolver, bypassAuthState = false) {
+ super(auth, [
+ "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */,
+ "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */,
+ "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */,
+ "unknown" /* AuthEventType.UNKNOWN */
+ ], resolver, undefined, bypassAuthState);
+ this.eventId = null;
+ }
+ /**
+ * Override the execute function; if we already have a redirect result, then
+ * just return it.
+ */
+ 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 we're not bypassing auth state, the ready outcome should be set to
+ // null.
+ if (!this.bypassAuthState) {
+ redirectOutcomeMap.set(this.auth._key(), () => Promise.resolve(null));
+ }
+ return readyOutcome();
+ }
+ async onAuthEvent(event) {
+ if (event.type === "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */) {
+ return super.onAuthEvent(event);
+ }
+ else if (event.type === "unknown" /* AuthEventType.UNKNOWN */) {
+ // This is a sentinel value indicating there's no pending redirect
+ 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, auth) {
+ const key = pendingRedirectKey(auth);
+ const persistence = resolverPersistence(resolver);
+ if (!(await persistence._isAvailable())) {
+ return false;
+ }
+ const hasPendingRedirect = (await persistence._get(key)) === 'true';
+ await persistence._remove(key);
+ return hasPendingRedirect;
+}
+async function _setPendingRedirectStatus(resolver, auth) {
+ return resolverPersistence(resolver)._set(pendingRedirectKey(auth), 'true');
+}
+function _clearRedirectOutcomes() {
+ redirectOutcomeMap.clear();
+}
+function _overrideRedirectResult(auth, result) {
+ redirectOutcomeMap.set(auth._key(), result);
+}
+function resolverPersistence(resolver) {
+ return index._getInstance(resolver._redirectPersistence);
+}
+function pendingRedirectKey(auth) {
+ return index._persistenceKeyName(PENDING_REDIRECT_KEY, auth.config.apiKey, auth.name);
+}
+
+/**
+ * @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.
+ */
+/**
+ * Authenticates a Firebase client using a full-page redirect flow.
+ *
+ * @remarks
+ * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+ * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+ * | best practices} when using {@link signInWithRedirect}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * // You can add additional scopes to the provider:
+ * provider.addScope('user_birthday');
+ * // Start a sign in process for an unauthenticated user.
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ * // This is the signed-in user
+ * const user = result.user;
+ * // This gives you a Facebook Access Token.
+ * const credential = provider.credentialFromResult(auth, result);
+ * const token = credential.accessToken;
+ * }
+ * // As this API can be used for sign-in, linking and reauthentication,
+ * // check the operationType to determine what triggered this redirect
+ * // operation.
+ * const operationType = result.operationType;
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+function signInWithRedirect(auth, provider, resolver) {
+ return _signInWithRedirect(auth, provider, resolver);
+}
+async function _signInWithRedirect(auth, provider, resolver) {
+ if (app._isFirebaseServerApp(auth.app)) {
+ return Promise.reject(index._serverAppCurrentUserOperationNotSupportedError(auth));
+ }
+ const authInternal = index._castAuth(auth);
+ index._assertInstanceOf(auth, provider, index.FederatedAuthProvider);
+ // Wait for auth initialization to complete, this will process pending redirects and clear the
+ // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new
+ // redirect and creating a PENDING_REDIRECT_KEY entry.
+ await authInternal._initializationPromise;
+ const resolverInternal = _withDefaultResolver(authInternal, resolver);
+ await _setPendingRedirectStatus(resolverInternal, authInternal);
+ return resolverInternal._openRedirect(authInternal, provider, "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */);
+}
+/**
+ * Reauthenticates the current user with the specified {@link OAuthProvider} using a full-page redirect flow.
+ * @remarks
+ * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+ * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+ * | best practices} when using {@link reauthenticateWithRedirect}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances
+ * created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * const result = await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * // Reauthenticate using a redirect.
+ * await reauthenticateWithRedirect(result.user, provider);
+ * // This will again trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+function reauthenticateWithRedirect(user, provider, resolver) {
+ return _reauthenticateWithRedirect(user, provider, resolver);
+}
+async function _reauthenticateWithRedirect(user, provider, resolver) {
+ const userInternal = util.getModularInstance(user);
+ index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider);
+ if (app._isFirebaseServerApp(userInternal.auth.app)) {
+ return Promise.reject(index._serverAppCurrentUserOperationNotSupportedError(userInternal.auth));
+ }
+ // Wait for auth initialization to complete, this will process pending redirects and clear the
+ // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new
+ // redirect and creating a PENDING_REDIRECT_KEY entry.
+ await userInternal.auth._initializationPromise;
+ // Allow the resolver to error before persisting the redirect user
+ const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
+ await _setPendingRedirectStatus(resolverInternal, userInternal.auth);
+ const eventId = await prepareUserForRedirect(userInternal);
+ return resolverInternal._openRedirect(userInternal.auth, provider, "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */, eventId);
+}
+/**
+ * Links the {@link OAuthProvider} to the user account using a full-page redirect flow.
+ * @remarks
+ * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+ * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+ * | best practices} when using {@link linkWithRedirect}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances
+ * created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using some other provider.
+ * const result = await signInWithEmailAndPassword(auth, email, password);
+ * // Link using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * await linkWithRedirect(result.user, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+function linkWithRedirect(user, provider, resolver) {
+ return _linkWithRedirect(user, provider, resolver);
+}
+async function _linkWithRedirect(user, provider, resolver) {
+ const userInternal = util.getModularInstance(user);
+ index._assertInstanceOf(userInternal.auth, provider, index.FederatedAuthProvider);
+ // Wait for auth initialization to complete, this will process pending redirects and clear the
+ // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new
+ // redirect and creating a PENDING_REDIRECT_KEY entry.
+ await userInternal.auth._initializationPromise;
+ // Allow the resolver to error before persisting the redirect user
+ const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
+ await index._assertLinkedStatus(false, userInternal, provider.providerId);
+ await _setPendingRedirectStatus(resolverInternal, userInternal.auth);
+ const eventId = await prepareUserForRedirect(userInternal);
+ return resolverInternal._openRedirect(userInternal.auth, provider, "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */, eventId);
+}
+/**
+ * Returns a {@link UserCredential} from the redirect-based sign-in flow.
+ *
+ * @remarks
+ * If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an
+ * error. If no redirect operation was called, returns `null`.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * // You can add additional scopes to the provider:
+ * provider.addScope('user_birthday');
+ * // Start a sign in process for an unauthenticated user.
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ * // This is the signed-in user
+ * const user = result.user;
+ * // This gives you a Facebook Access Token.
+ * const credential = provider.credentialFromResult(auth, result);
+ * const token = credential.accessToken;
+ * }
+ * // As this API can be used for sign-in, linking and reauthentication,
+ * // check the operationType to determine what triggered this redirect
+ * // operation.
+ * const operationType = result.operationType;
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+async function getRedirectResult(auth, resolver) {
+ await index._castAuth(auth)._initializationPromise;
+ return _getRedirectResult(auth, resolver, false);
+}
+async function _getRedirectResult(auth, resolverExtern, bypassAuthState = false) {
+ if (app._isFirebaseServerApp(auth.app)) {
+ return Promise.reject(index._serverAppCurrentUserOperationNotSupportedError(auth));
+ }
+ const authInternal = index._castAuth(auth);
+ 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;
+}
+async function prepareUserForRedirect(user) {
+ const eventId = _generateEventId(`${user.uid}:::`);
+ user._redirectEventId = eventId;
+ await user.auth._setRedirectUser(user);
+ await user.auth._persistUserIfCurrent(user);
+ return eventId;
+}
+
+/**
+ * @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.
+ */
+// The amount of time to store the UIDs of seen events; this is
+// set to 10 min by default
+const EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1000;
+class AuthEventManager {
+ constructor(auth) {
+ this.auth = auth;
+ this.cachedEventUids = new Set();
+ this.consumers = 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) {
+ // Check if the event has already been handled
+ 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)) {
+ // If we've already seen a redirect before, or this is a popup event,
+ // bail now
+ return handled;
+ }
+ this.hasHandledPotentialRedirect = true;
+ // If the redirect wasn't handled, hang on to it
+ if (!handled) {
+ this.queuedRedirectEvent = event;
+ handled = true;
+ }
+ return handled;
+ }
+ sendToConsumer(event, consumer) {
+ if (event.error && !isNullRedirectEvent(event)) {
+ const code = event.error.code?.split('auth/')[1] ||
+ "internal-error" /* AuthErrorCode.INTERNAL_ERROR */;
+ consumer.onError(index._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(v => v).join('-');
+}
+function isNullRedirectEvent({ type, error }) {
+ return (type === "unknown" /* AuthEventType.UNKNOWN */ &&
+ error?.code === `auth/${"no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */}`);
+}
+function isRedirectEvent(event) {
+ switch (event.type) {
+ case "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */:
+ case "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */:
+ case "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */:
+ return true;
+ case "unknown" /* AuthEventType.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(auth, request = {}) {
+ return index._performApiRequest(auth, "GET" /* HttpMethod.GET */, "/v1/projects" /* Endpoint.GET_PROJECT_CONFIG */, 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$1(auth) {
+ // Skip origin validation if we are in an emulated environment
+ if (auth.config.emulator) {
+ return;
+ }
+ const { authorizedDomains } = await _getProjectConfig(auth);
+ for (const domain of authorizedDomains) {
+ try {
+ if (matchDomain(domain)) {
+ return;
+ }
+ }
+ catch {
+ // Do nothing if there's a URL error; just continue searching
+ }
+ }
+ // In the old SDK, this error also provides helpful messages.
+ index._fail(auth, "unauthorized-domain" /* AuthErrorCode.INVALID_ORIGIN */);
+}
+function matchDomain(expected) {
+ const currentUrl = index._getCurrentUrl();
+ const { protocol, hostname } = new URL(currentUrl);
+ if (expected.startsWith('chrome-extension://')) {
+ const ceUrl = new URL(expected);
+ if (ceUrl.hostname === '' && hostname === '') {
+ // For some reason we're not parsing chrome URLs properly
+ 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)) {
+ // The domain has to be exactly equal to the pattern, as an IP domain will
+ // only contain the IP, no extra character.
+ return hostname === expected;
+ }
+ // Dots in pattern should be escaped.
+ const escapedDomainPattern = expected.replace(/\./g, '\\.');
+ // Non ip address domains.
+ // domain.com = *.domain.com OR domain.com
+ 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 index.Delay(30000, 60000);
+/**
+ * Reset unloaded GApi modules. If gapi.load fails due to a network error,
+ * it will stop working after a retrial. This is a hack to fix this issue.
+ */
+function resetUnloadedGapiModules() {
+ // Clear last failed gapi.load state to force next gapi.load to first
+ // load the failed gapi.iframes module.
+ // Get gapix.beacon context.
+ const beacon = index._window().___jsl;
+ // Get current hint.
+ if (beacon?.H) {
+ // Get gapi hint.
+ for (const hint of Object.keys(beacon.H)) {
+ // Requested modules.
+ beacon.H[hint].r = beacon.H[hint].r || [];
+ // Loaded modules.
+ beacon.H[hint].L = beacon.H[hint].L || [];
+ // Set requested modules to a copy of the loaded modules.
+ beacon.H[hint].r = [...beacon.H[hint].L];
+ // Clear pending callbacks.
+ if (beacon.CP) {
+ for (let i = 0; i < beacon.CP.length; i++) {
+ // Remove all failed pending callbacks.
+ beacon.CP[i] = null;
+ }
+ }
+ }
+ }
+}
+function loadGapi(auth) {
+ return new Promise((resolve, reject) => {
+ // Function to run when gapi.load is ready.
+ function loadGapiIframe() {
+ // The developer may have tried to previously run gapi.load and failed.
+ // Run this to fix that.
+ resetUnloadedGapiModules();
+ gapi.load('gapi.iframes', {
+ callback: () => {
+ resolve(gapi.iframes.getContext());
+ },
+ ontimeout: () => {
+ // The above reset may be sufficient, but having this reset after
+ // failure ensures that if the developer calls gapi.load after the
+ // connection is re-established and before another attempt to embed
+ // the iframe, it would work and would not be broken because of our
+ // failed attempt.
+ // Timeout when gapi.iframes.Iframe not loaded.
+ resetUnloadedGapiModules();
+ reject(index._createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */));
+ },
+ timeout: NETWORK_TIMEOUT.get()
+ });
+ }
+ if (index._window().gapi?.iframes?.Iframe) {
+ // If gapi.iframes.Iframe available, resolve.
+ resolve(gapi.iframes.getContext());
+ }
+ else if (!!index._window().gapi?.load) {
+ // Gapi loader ready, load gapi.iframes.
+ loadGapiIframe();
+ }
+ else {
+ // Create a new iframe callback when this is called so as not to overwrite
+ // any previous defined callback. This happens if this method is called
+ // multiple times in parallel and could result in the later callback
+ // overwriting the previous one. This would end up with a iframe
+ // timeout.
+ const cbName = index._generateCallbackName('iframefcb');
+ // GApi loader not available, dynamically load platform.js.
+ index._window()[cbName] = () => {
+ // GApi loader should be ready.
+ if (!!gapi.load) {
+ loadGapiIframe();
+ }
+ else {
+ // Gapi loader failed, throw error.
+ reject(index._createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */));
+ }
+ };
+ // Load GApi loader.
+ return index._loadJS(`${index._gapiScriptUrl()}?onload=${cbName}`)
+ .catch(e => reject(e));
+ }
+ }).catch(error => {
+ // Reset cached promise to allow for retrial.
+ cachedGApiLoader = null;
+ throw error;
+ });
+}
+let cachedGApiLoader = null;
+function _loadGapi(auth) {
+ cachedGApiLoader = cachedGApiLoader || loadGapi(auth);
+ 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 index.Delay(5000, 15000);
+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'
+};
+// Map from apiHost to endpoint ID for passing into iframe. In current SDK, apiHost can be set to
+// anything (not from a list of endpoints with IDs as in legacy), so this is the closest we can get.
+const EID_FROM_APIHOST = new Map([
+ ["identitytoolkit.googleapis.com" /* DefaultConfig.API_HOST */, 'p'], // production
+ ['staging-identitytoolkit.sandbox.googleapis.com', 's'], // staging
+ ['test-identitytoolkit.sandbox.googleapis.com', 't'] // test
+]);
+function getIframeUrl(auth) {
+ const config = auth.config;
+ index._assert(config.authDomain, auth, "auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */);
+ const url = config.emulator
+ ? index._emulatorUrl(config, EMULATED_IFRAME_PATH)
+ : `https://${auth.config.authDomain}/${IFRAME_PATH}`;
+ const params = {
+ apiKey: config.apiKey,
+ appName: auth.name,
+ v: app.SDK_VERSION
+ };
+ const eid = EID_FROM_APIHOST.get(auth.config.apiHost);
+ if (eid) {
+ params.eid = eid;
+ }
+ const frameworks = auth._getFrameworks();
+ if (frameworks.length) {
+ params.fw = frameworks.join(',');
+ }
+ return `${url}?${util.querystring(params).slice(1)}`;
+}
+async function _openIframe(auth) {
+ const context = await _loadGapi(auth);
+ const gapi = index._window().gapi;
+ index._assert(gapi, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ return context.open({
+ where: document.body,
+ url: getIframeUrl(auth),
+ messageHandlersFilter: gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER,
+ attributes: IFRAME_ATTRIBUTES,
+ dontclear: true
+ }, (iframe) => new Promise(async (resolve, reject) => {
+ await iframe.restyle({
+ // Prevent iframe from closing on mouse out.
+ setHideOnLeave: false
+ });
+ const networkError = index._createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */);
+ // Confirm iframe is correctly loaded.
+ // To fallback on failure, set a timeout.
+ const networkErrorTimer = index._window().setTimeout(() => {
+ reject(networkError);
+ }, PING_TIMEOUT.get());
+ // Clear timer and resolve pending iframe ready promise.
+ function clearTimerAndResolve() {
+ index._window().clearTimeout(networkErrorTimer);
+ resolve(iframe);
+ }
+ // This returns an IThenable. However the reject part does not call
+ // when the iframe is not loaded.
+ 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(window) {
+ this.window = window;
+ this.associatedEvent = null;
+ }
+ close() {
+ if (this.window) {
+ try {
+ this.window.close();
+ }
+ catch (e) { }
+ }
+ }
+}
+function _open(auth, url, name, 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 = {
+ ...BASE_POPUP_OPTIONS,
+ width: width.toString(),
+ height: height.toString(),
+ top,
+ left
+ };
+ // Chrome iOS 7 and 8 is returning an undefined popup win when target is
+ // specified, even though the popup is not necessarily blocked.
+ const ua = util.getUA().toLowerCase();
+ if (name) {
+ target = index._isChromeIOS(ua) ? TARGET_BLANK : name;
+ }
+ if (index._isFirefox(ua)) {
+ // Firefox complains when invalid URLs are popped out. Hacky way to bypass.
+ url = url || FIREFOX_EMPTY_URL;
+ // Firefox disables by default scrolling on popup windows, which can create
+ // issues when the user has many Google accounts, for instance.
+ options.scrollbars = 'yes';
+ }
+ const optionsString = Object.entries(options).reduce((accum, [key, value]) => `${accum}${key}=${value},`, '');
+ if (index._isIOSStandalone(ua) && target !== '_self') {
+ openAsNewWindowIOS(url || '', target);
+ return new AuthPopup(null);
+ }
+ // about:blank getting sanitized causing browsers like IE/Edge to display
+ // brief error message before redirecting to handler.
+ const newWin = window.open(url || '', target, optionsString);
+ index._assert(newWin, auth, "popup-blocked" /* AuthErrorCode.POPUP_BLOCKED */);
+ // Flaky on IE edge, encapsulate with a try and catch.
+ try {
+ newWin.focus();
+ }
+ catch (e) { }
+ return new AuthPopup(newWin);
+}
+function openAsNewWindowIOS(url, target) {
+ const el = document.createElement('a');
+ el.href = url;
+ el.target = target;
+ const click = document.createEvent('MouseEvent');
+ click.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 1, null);
+ el.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.
+ */
+/**
+ * URL for Authentication widget which will initiate the OAuth handshake
+ *
+ * @internal
+ */
+const WIDGET_PATH = '__/auth/handler';
+/**
+ * URL for emulated environment
+ *
+ * @internal
+ */
+const EMULATOR_WIDGET_PATH = 'emulator/auth/handler';
+/**
+ * Fragment name for the App Check token that gets passed to the widget
+ *
+ * @internal
+ */
+const FIREBASE_APP_CHECK_FRAGMENT_ID = encodeURIComponent('fac');
+async function _getRedirectUrl(auth, provider, authType, redirectUrl, eventId, additionalParams) {
+ index._assert(auth.config.authDomain, auth, "auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */);
+ index._assert(auth.config.apiKey, auth, "invalid-api-key" /* AuthErrorCode.INVALID_API_KEY */);
+ const params = {
+ apiKey: auth.config.apiKey,
+ appName: auth.name,
+ authType,
+ redirectUrl,
+ v: app.SDK_VERSION,
+ eventId
+ };
+ if (provider instanceof index.FederatedAuthProvider) {
+ provider.setDefaultLanguage(auth.languageCode);
+ params.providerId = provider.providerId || '';
+ if (!util.isEmpty(provider.getCustomParameters())) {
+ params.customParameters = JSON.stringify(provider.getCustomParameters());
+ }
+ // TODO set additionalParams from the provider as well?
+ for (const [key, value] of Object.entries(additionalParams || {})) {
+ params[key] = value;
+ }
+ }
+ if (provider instanceof index.BaseOAuthProvider) {
+ const scopes = provider.getScopes().filter(scope => scope !== '');
+ if (scopes.length > 0) {
+ params.scopes = scopes.join(',');
+ }
+ }
+ if (auth.tenantId) {
+ params.tid = auth.tenantId;
+ }
+ // TODO: maybe set eid as endpointId
+ // TODO: maybe set fw as Frameworks.join(",")
+ const paramsDict = params;
+ for (const key of Object.keys(paramsDict)) {
+ if (paramsDict[key] === undefined) {
+ delete paramsDict[key];
+ }
+ }
+ // Sets the App Check token to pass to the widget
+ const appCheckToken = await auth._getAppCheckToken();
+ const appCheckTokenFragment = appCheckToken
+ ? `#${FIREBASE_APP_CHECK_FRAGMENT_ID}=${encodeURIComponent(appCheckToken)}`
+ : '';
+ // Start at index 1 to skip the leading '&' in the query string
+ return `${getHandlerBase(auth)}?${util.querystring(paramsDict).slice(1)}${appCheckTokenFragment}`;
+}
+function getHandlerBase({ config }) {
+ if (!config.emulator) {
+ return `https://${config.authDomain}/${WIDGET_PATH}`;
+ }
+ return index._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.
+ */
+/**
+ * The special web storage event
+ *
+ */
+const WEB_STORAGE_SUPPORT_KEY = 'webStorageSupport';
+class BrowserPopupRedirectResolver {
+ constructor() {
+ this.eventManagers = {};
+ this.iframes = {};
+ this.originValidationPromises = {};
+ this._redirectPersistence = browserSessionPersistence;
+ this._completeRedirectFn = _getRedirectResult;
+ this._overrideRedirectResult = _overrideRedirectResult;
+ }
+ // Wrapping in async even though we don't await anywhere in order
+ // to make sure errors are raised as promise rejections
+ async _openPopup(auth, provider, authType, eventId) {
+ index.debugAssert(this.eventManagers[auth._key()]?.manager, '_initialize() not called before _openPopup()');
+ const url = await _getRedirectUrl(auth, provider, authType, index._getCurrentUrl(), eventId);
+ return _open(auth, url, _generateEventId());
+ }
+ async _openRedirect(auth, provider, authType, eventId) {
+ await this._originValidation(auth);
+ const url = await _getRedirectUrl(auth, provider, authType, index._getCurrentUrl(), eventId);
+ index._setWindowLocation(url);
+ return new Promise(() => { });
+ }
+ _initialize(auth) {
+ const key = auth._key();
+ if (this.eventManagers[key]) {
+ const { manager, promise } = this.eventManagers[key];
+ if (manager) {
+ return Promise.resolve(manager);
+ }
+ else {
+ index.debugAssert(promise, 'If manager is not set, promise should be');
+ return promise;
+ }
+ }
+ const promise = this.initAndGetManager(auth);
+ this.eventManagers[key] = { promise };
+ // If the promise is rejected, the key should be removed so that the
+ // operation can be retried later.
+ promise.catch(() => {
+ delete this.eventManagers[key];
+ });
+ return promise;
+ }
+ async initAndGetManager(auth) {
+ const iframe = await _openIframe(auth);
+ const manager = new AuthEventManager(auth);
+ iframe.register('authEvent', (iframeEvent) => {
+ index._assert(iframeEvent?.authEvent, auth, "invalid-auth-event" /* AuthErrorCode.INVALID_AUTH_EVENT */);
+ // TODO: Consider splitting redirect and popup events earlier on
+ const handled = manager.onEvent(iframeEvent.authEvent);
+ return { status: handled ? "ACK" /* GapiOutcome.ACK */ : "ERROR" /* GapiOutcome.ERROR */ };
+ }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+ this.eventManagers[auth._key()] = { manager };
+ this.iframes[auth._key()] = iframe;
+ return manager;
+ }
+ _isIframeWebStorageSupported(auth, cb) {
+ const iframe = this.iframes[auth._key()];
+ iframe.send(WEB_STORAGE_SUPPORT_KEY, { type: WEB_STORAGE_SUPPORT_KEY }, result => {
+ const isSupported = result?.[0]?.[WEB_STORAGE_SUPPORT_KEY];
+ if (isSupported !== undefined) {
+ cb(!!isSupported);
+ }
+ index._fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+ }
+ _originValidation(auth) {
+ const key = auth._key();
+ if (!this.originValidationPromises[key]) {
+ this.originValidationPromises[key] = _validateOrigin$1(auth);
+ }
+ return this.originValidationPromises[key];
+ }
+ get _shouldInitProactively() {
+ // Mobile browsers and Safari need to optimistically initialize
+ return index._isMobileBrowser() || index._isSafari() || index._isIOS();
+ }
+}
+/**
+ * An implementation of {@link PopupRedirectResolver} suitable for browser
+ * based applications.
+ *
+ * @remarks
+ * This method does not work in a Node.js environment.
+ *
+ * @public
+ */
+const browserPopupRedirectResolver = BrowserPopupRedirectResolver;
+
+/**
+ * @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 = util.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)) / 1000;
+ if (idTokenAge && idTokenAge > authIdTokenMaxAge) {
+ return;
+ }
+ // Specifically trip null => undefined when logged out, to delete any existing cookie
+ const idToken = idTokenResult?.token;
+ if (lastPostedIdToken === idToken) {
+ return;
+ }
+ lastPostedIdToken = idToken;
+ await fetch(url, {
+ method: idToken ? 'POST' : 'DELETE',
+ headers: idToken
+ ? {
+ 'Authorization': `Bearer ${idToken}`
+ }
+ : {}
+ });
+};
+/**
+ * Returns the Auth instance associated with the provided {@link @firebase/app#FirebaseApp}.
+ * If no instance exists, initializes an Auth instance with platform-specific default dependencies.
+ *
+ * @param app - The Firebase App.
+ *
+ * @public
+ */
+function getAuth(app$1 = app.getApp()) {
+ const provider = app._getProvider(app$1, 'auth');
+ if (provider.isInitialized()) {
+ return provider.getImmediate();
+ }
+ const auth = index.initializeAuth(app$1, {
+ popupRedirectResolver: browserPopupRedirectResolver,
+ persistence: [
+ indexedDBLocalPersistence,
+ browserLocalPersistence,
+ browserSessionPersistence
+ ]
+ });
+ const authTokenSyncPath = util.getExperimentalSetting('authTokenSyncURL');
+ // Only do the Cookie exchange in a secure context
+ if (authTokenSyncPath &&
+ typeof isSecureContext === 'boolean' &&
+ isSecureContext) {
+ // Don't allow urls (XSS possibility), only paths on the same domain
+ const authTokenSyncUrl = new URL(authTokenSyncPath, location.origin);
+ if (location.origin === authTokenSyncUrl.origin) {
+ const mintCookie = mintCookieFactory(authTokenSyncUrl.toString());
+ index.beforeAuthStateChanged(auth, mintCookie, () => mintCookie(auth.currentUser));
+ index.onIdTokenChanged(auth, user => mintCookie(user));
+ }
+ }
+ const authEmulatorHost = util.getDefaultEmulatorHost('auth');
+ if (authEmulatorHost) {
+ index.connectAuthEmulator(auth, `http://${authEmulatorHost}`);
+ }
+ return auth;
+}
+function getScriptParentElement() {
+ return document.getElementsByTagName('head')?.[0] ?? document;
+}
+index._setExternalJSProvider({
+ loadJS(url) {
+ // TODO: consider adding timeout support & cancellation
+ return new Promise((resolve, reject) => {
+ const el = document.createElement('script');
+ el.setAttribute('src', url);
+ el.onload = resolve;
+ el.onerror = e => {
+ const error = index._createError("internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+ error.customData = e;
+ reject(error);
+ };
+ el.type = 'text/javascript';
+ el.charset = 'UTF-8';
+ getScriptParentElement().appendChild(el);
+ });
+ },
+ gapiScript: 'https://apis.google.com/js/api.js',
+ recaptchaV2Script: 'https://www.google.com/recaptcha/api.js',
+ recaptchaEnterpriseScript: 'https://www.google.com/recaptcha/enterprise.js?render='
+});
+index.registerAuth("Browser" /* ClientPlatform.BROWSER */);
+
+/**
+ * @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 _cordovaWindow() {
+ return window;
+}
+
+/**
+ * @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.
+ */
+/**
+ * How long to wait after the app comes back into focus before concluding that
+ * the user closed the sign in tab.
+ */
+const REDIRECT_TIMEOUT_MS = 2000;
+/**
+ * Generates the URL for the OAuth handler.
+ */
+async function _generateHandlerUrl(auth, event, provider) {
+ // Get the cordova plugins
+ const { BuildInfo } = _cordovaWindow();
+ index.debugAssert(event.sessionId, 'AuthEvent did not contain a session ID');
+ const sessionDigest = await computeSha256(event.sessionId);
+ const additionalParams = {};
+ if (index._isIOS()) {
+ // iOS app identifier
+ additionalParams['ibi'] = BuildInfo.packageName;
+ }
+ else if (index._isAndroid()) {
+ // Android app identifier
+ additionalParams['apn'] = BuildInfo.packageName;
+ }
+ else {
+ index._fail(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */);
+ }
+ // Add the display name if available
+ if (BuildInfo.displayName) {
+ additionalParams['appDisplayName'] = BuildInfo.displayName;
+ }
+ // Attached the hashed session ID
+ additionalParams['sessionId'] = sessionDigest;
+ return _getRedirectUrl(auth, provider, event.type, undefined, event.eventId ?? undefined, additionalParams);
+}
+/**
+ * Validates that this app is valid for this project configuration
+ */
+async function _validateOrigin(auth) {
+ const { BuildInfo } = _cordovaWindow();
+ const request = {};
+ if (index._isIOS()) {
+ request.iosBundleId = BuildInfo.packageName;
+ }
+ else if (index._isAndroid()) {
+ request.androidPackageName = BuildInfo.packageName;
+ }
+ else {
+ index._fail(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */);
+ }
+ // Will fail automatically if package name is not authorized
+ await _getProjectConfig(auth, request);
+}
+function _performRedirect(handlerUrl) {
+ // Get the cordova plugins
+ const { cordova } = _cordovaWindow();
+ return new Promise(resolve => {
+ cordova.plugins.browsertab.isAvailable(browserTabIsAvailable => {
+ let iabRef = null;
+ if (browserTabIsAvailable) {
+ cordova.plugins.browsertab.openUrl(handlerUrl);
+ }
+ else {
+ // TODO: Return the inappbrowser ref that's returned from the open call
+ iabRef = cordova.InAppBrowser.open(handlerUrl, index._isIOS7Or8() ? '_blank' : '_system', 'location=yes');
+ }
+ resolve(iabRef);
+ });
+ });
+}
+/**
+ * This function waits for app activity to be seen before resolving. It does
+ * this by attaching listeners to various dom events. Once the app is determined
+ * to be visible, this promise resolves. AFTER that resolution, the listeners
+ * are detached and any browser tabs left open will be closed.
+ */
+async function _waitForAppResume(auth, eventListener, iabRef) {
+ // Get the cordova plugins
+ const { cordova } = _cordovaWindow();
+ let cleanup = () => { };
+ try {
+ await new Promise((resolve, reject) => {
+ let onCloseTimer = null;
+ // DEFINE ALL THE CALLBACKS =====
+ function authEventSeen() {
+ // Auth event was detected. Resolve this promise and close the extra
+ // window if it's still open.
+ resolve();
+ const closeBrowserTab = cordova.plugins.browsertab?.close;
+ if (typeof closeBrowserTab === 'function') {
+ closeBrowserTab();
+ }
+ // Close inappbrowser embedded webview in iOS7 and 8 case if still
+ // open.
+ if (typeof iabRef?.close === 'function') {
+ iabRef.close();
+ }
+ }
+ function resumed() {
+ if (onCloseTimer) {
+ // This code already ran; do not rerun.
+ return;
+ }
+ onCloseTimer = window.setTimeout(() => {
+ // Wait two seconds after resume then reject.
+ reject(index._createError(auth, "redirect-cancelled-by-user" /* AuthErrorCode.REDIRECT_CANCELLED_BY_USER */));
+ }, REDIRECT_TIMEOUT_MS);
+ }
+ function visibilityChanged() {
+ if (document?.visibilityState === 'visible') {
+ resumed();
+ }
+ }
+ // ATTACH ALL THE LISTENERS =====
+ // Listen for the auth event
+ eventListener.addPassiveListener(authEventSeen);
+ // Listen for resume and visibility events
+ document.addEventListener('resume', resumed, false);
+ if (index._isAndroid()) {
+ document.addEventListener('visibilitychange', visibilityChanged, false);
+ }
+ // SETUP THE CLEANUP FUNCTION =====
+ cleanup = () => {
+ eventListener.removePassiveListener(authEventSeen);
+ document.removeEventListener('resume', resumed, false);
+ document.removeEventListener('visibilitychange', visibilityChanged, false);
+ if (onCloseTimer) {
+ window.clearTimeout(onCloseTimer);
+ }
+ };
+ });
+ }
+ finally {
+ cleanup();
+ }
+}
+/**
+ * Checks the configuration of the Cordova environment. This has no side effect
+ * if the configuration is correct; otherwise it throws an error with the
+ * missing plugin.
+ */
+function _checkCordovaConfiguration(auth) {
+ const win = _cordovaWindow();
+ // Check all dependencies installed.
+ // https://github.com/nordnet/cordova-universal-links-plugin
+ // Note that cordova-universal-links-plugin has been abandoned.
+ // A fork with latest fixes is available at:
+ // https://www.npmjs.com/package/cordova-universal-links-plugin-fix
+ index._assert(typeof win?.universalLinks?.subscribe === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, {
+ missingPlugin: 'cordova-universal-links-plugin-fix'
+ });
+ // https://www.npmjs.com/package/cordova-plugin-buildinfo
+ index._assert(typeof win?.BuildInfo?.packageName !== 'undefined', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, {
+ missingPlugin: 'cordova-plugin-buildInfo'
+ });
+ // https://github.com/google/cordova-plugin-browsertab
+ index._assert(typeof win?.cordova?.plugins?.browsertab?.openUrl === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, {
+ missingPlugin: 'cordova-plugin-browsertab'
+ });
+ index._assert(typeof win?.cordova?.plugins?.browsertab?.isAvailable === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, {
+ missingPlugin: 'cordova-plugin-browsertab'
+ });
+ // https://cordova.apache.org/docs/en/latest/reference/cordova-plugin-inappbrowser/
+ index._assert(typeof win?.cordova?.InAppBrowser?.open === 'function', auth, "invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */, {
+ missingPlugin: 'cordova-plugin-inappbrowser'
+ });
+}
+/**
+ * Computes the SHA-256 of a session ID. The SubtleCrypto interface is only
+ * available in "secure" contexts, which covers Cordova (which is served on a file
+ * protocol).
+ */
+async function computeSha256(sessionId) {
+ const bytes = stringToArrayBuffer(sessionId);
+ // TODO: For IE11 crypto has a different name and this operation comes back
+ // as an object, not a promise. This is the old proposed standard that
+ // is used by IE11:
+ // https://www.w3.org/TR/2013/WD-WebCryptoAPI-20130108/#cryptooperation-interface
+ const buf = await crypto.subtle.digest('SHA-256', bytes);
+ const arr = Array.from(new Uint8Array(buf));
+ return arr.map(num => num.toString(16).padStart(2, '0')).join('');
+}
+function stringToArrayBuffer(str) {
+ // This function is only meant to deal with an ASCII charset and makes
+ // certain simplifying assumptions.
+ index.debugAssert(/[0-9a-zA-Z]+/.test(str), 'Can only convert alpha-numeric strings');
+ if (typeof TextEncoder !== 'undefined') {
+ return new TextEncoder().encode(str);
+ }
+ const buff = new ArrayBuffer(str.length);
+ const view = new Uint8Array(buff);
+ for (let i = 0; i < str.length; i++) {
+ view[i] = str.charCodeAt(i);
+ }
+ return view;
+}
+
+/**
+ * @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 SESSION_ID_LENGTH = 20;
+/** Custom AuthEventManager that adds passive listeners to events */
+class CordovaAuthEventManager extends AuthEventManager {
+ constructor() {
+ super(...arguments);
+ this.passiveListeners = new Set();
+ this.initPromise = new Promise(resolve => {
+ this.resolveInitialized = resolve;
+ });
+ }
+ addPassiveListener(cb) {
+ this.passiveListeners.add(cb);
+ }
+ removePassiveListener(cb) {
+ this.passiveListeners.delete(cb);
+ }
+ // In a Cordova environment, this manager can live through multiple redirect
+ // operations
+ resetRedirect() {
+ this.queuedRedirectEvent = null;
+ this.hasHandledPotentialRedirect = false;
+ }
+ /** Override the onEvent method */
+ onEvent(event) {
+ this.resolveInitialized();
+ this.passiveListeners.forEach(cb => cb(event));
+ return super.onEvent(event);
+ }
+ async initialized() {
+ await this.initPromise;
+ }
+}
+/**
+ * Generates a (partial) {@link AuthEvent}.
+ */
+function _generateNewEvent(auth, type, eventId = null) {
+ return {
+ type,
+ eventId,
+ urlResponse: null,
+ sessionId: generateSessionId(),
+ postBody: null,
+ tenantId: auth.tenantId,
+ error: index._createError(auth, "no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */)
+ };
+}
+function _savePartialEvent(auth, event) {
+ return storage()._set(persistenceKey(auth), event);
+}
+async function _getAndRemoveEvent(auth) {
+ const event = (await storage()._get(persistenceKey(auth)));
+ if (event) {
+ await storage()._remove(persistenceKey(auth));
+ }
+ return event;
+}
+function _eventFromPartialAndUrl(partialEvent, url) {
+ // Parse the deep link within the dynamic link URL.
+ const callbackUrl = _getDeepLinkFromCallback(url);
+ // Confirm it is actually a callback URL.
+ // Currently the universal link will be of this format:
+ // https://<AUTH_DOMAIN>/__/auth/callback<OAUTH_RESPONSE>
+ // This is a fake URL but is not intended to take the user anywhere
+ // and just redirect to the app.
+ if (callbackUrl.includes('/__/auth/callback')) {
+ // Check if there is an error in the URL.
+ // This mechanism is also used to pass errors back to the app:
+ // https://<AUTH_DOMAIN>/__/auth/callback?firebaseError=<STRINGIFIED_ERROR>
+ const params = searchParamsOrEmpty(callbackUrl);
+ // Get the error object corresponding to the stringified error if found.
+ const errorObject = params['firebaseError']
+ ? parseJsonOrNull(decodeURIComponent(params['firebaseError']))
+ : null;
+ const code = errorObject?.['code']?.split('auth/')?.[1];
+ const error = code ? index._createError(code) : null;
+ if (error) {
+ return {
+ type: partialEvent.type,
+ eventId: partialEvent.eventId,
+ tenantId: partialEvent.tenantId,
+ error,
+ urlResponse: null,
+ sessionId: null,
+ postBody: null
+ };
+ }
+ else {
+ return {
+ type: partialEvent.type,
+ eventId: partialEvent.eventId,
+ tenantId: partialEvent.tenantId,
+ sessionId: partialEvent.sessionId,
+ urlResponse: callbackUrl,
+ postBody: null
+ };
+ }
+ }
+ return null;
+}
+function generateSessionId() {
+ const chars = [];
+ const allowedChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+ for (let i = 0; i < SESSION_ID_LENGTH; i++) {
+ const idx = Math.floor(Math.random() * allowedChars.length);
+ chars.push(allowedChars.charAt(idx));
+ }
+ return chars.join('');
+}
+function storage() {
+ return index._getInstance(browserLocalPersistence);
+}
+function persistenceKey(auth) {
+ return index._persistenceKeyName("authEvent" /* KeyName.AUTH_EVENT */, auth.config.apiKey, auth.name);
+}
+function parseJsonOrNull(json) {
+ try {
+ return JSON.parse(json);
+ }
+ catch (e) {
+ return null;
+ }
+}
+// Exported for testing
+function _getDeepLinkFromCallback(url) {
+ const params = searchParamsOrEmpty(url);
+ const link = params['link'] ? decodeURIComponent(params['link']) : undefined;
+ // Double link case (automatic redirect)
+ const doubleDeepLink = searchParamsOrEmpty(link)['link'];
+ // iOS custom scheme links.
+ const iOSDeepLink = params['deep_link_id']
+ ? decodeURIComponent(params['deep_link_id'])
+ : undefined;
+ const iOSDoubleDeepLink = searchParamsOrEmpty(iOSDeepLink)['link'];
+ return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
+}
+/**
+ * Optimistically tries to get search params from a string, or else returns an
+ * empty search params object.
+ */
+function searchParamsOrEmpty(url) {
+ if (!url?.includes('?')) {
+ return {};
+ }
+ const [_, ...rest] = url.split('?');
+ return util.querystringDecode(rest.join('?'));
+}
+
+/**
+ * @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.
+ */
+/**
+ * How long to wait for the initial auth event before concluding no
+ * redirect pending
+ */
+const INITIAL_EVENT_TIMEOUT_MS = 500;
+class CordovaPopupRedirectResolver {
+ constructor() {
+ this._redirectPersistence = browserSessionPersistence;
+ this._shouldInitProactively = true; // This is lightweight for Cordova
+ this.eventManagers = new Map();
+ this.originValidationPromises = {};
+ this._completeRedirectFn = _getRedirectResult;
+ this._overrideRedirectResult = _overrideRedirectResult;
+ }
+ async _initialize(auth) {
+ const key = auth._key();
+ let manager = this.eventManagers.get(key);
+ if (!manager) {
+ manager = new CordovaAuthEventManager(auth);
+ this.eventManagers.set(key, manager);
+ this.attachCallbackListeners(auth, manager);
+ }
+ return manager;
+ }
+ _openPopup(auth) {
+ index._fail(auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */);
+ }
+ async _openRedirect(auth, provider, authType, eventId) {
+ _checkCordovaConfiguration(auth);
+ const manager = await this._initialize(auth);
+ await manager.initialized();
+ // Reset the persisted redirect states. This does not matter on Web where
+ // the redirect always blows away application state entirely. On Cordova,
+ // the app maintains control flow through the redirect.
+ manager.resetRedirect();
+ _clearRedirectOutcomes();
+ await this._originValidation(auth);
+ const event = _generateNewEvent(auth, authType, eventId);
+ await _savePartialEvent(auth, event);
+ const url = await _generateHandlerUrl(auth, event, provider);
+ const iabRef = await _performRedirect(url);
+ return _waitForAppResume(auth, manager, iabRef);
+ }
+ _isIframeWebStorageSupported(_auth, _cb) {
+ throw new Error('Method not implemented.');
+ }
+ _originValidation(auth) {
+ const key = auth._key();
+ if (!this.originValidationPromises[key]) {
+ this.originValidationPromises[key] = _validateOrigin(auth);
+ }
+ return this.originValidationPromises[key];
+ }
+ attachCallbackListeners(auth, manager) {
+ // Get the global plugins
+ const { universalLinks, handleOpenURL, BuildInfo } = _cordovaWindow();
+ const noEventTimeout = setTimeout(async () => {
+ // We didn't see that initial event. Clear any pending object and
+ // dispatch no event
+ await _getAndRemoveEvent(auth);
+ manager.onEvent(generateNoEvent());
+ }, INITIAL_EVENT_TIMEOUT_MS);
+ const universalLinksCb = async (eventData) => {
+ // We have an event so we can clear the no event timeout
+ clearTimeout(noEventTimeout);
+ const partialEvent = await _getAndRemoveEvent(auth);
+ let finalEvent = null;
+ if (partialEvent && eventData?.['url']) {
+ finalEvent = _eventFromPartialAndUrl(partialEvent, eventData['url']);
+ }
+ // If finalEvent is never filled, trigger with no event
+ manager.onEvent(finalEvent || generateNoEvent());
+ };
+ // Universal links subscriber doesn't exist for iOS, so we need to check
+ if (typeof universalLinks !== 'undefined' &&
+ typeof universalLinks.subscribe === 'function') {
+ universalLinks.subscribe(null, universalLinksCb);
+ }
+ // iOS 7 or 8 custom URL schemes.
+ // This is also the current default behavior for iOS 9+.
+ // For this to work, cordova-plugin-customurlscheme needs to be installed.
+ // https://github.com/EddyVerbruggen/Custom-URL-scheme
+ // Do not overwrite the existing developer's URL handler.
+ const existingHandleOpenURL = handleOpenURL;
+ const packagePrefix = `${BuildInfo.packageName.toLowerCase()}://`;
+ _cordovaWindow().handleOpenURL = async (url) => {
+ if (url.toLowerCase().startsWith(packagePrefix)) {
+ // We want this intentionally to float
+ // eslint-disable-next-line @typescript-eslint/no-floating-promises
+ universalLinksCb({ url });
+ }
+ // Call the developer's handler if it is present.
+ if (typeof existingHandleOpenURL === 'function') {
+ try {
+ existingHandleOpenURL(url);
+ }
+ catch (e) {
+ // This is a developer error. Don't stop the flow of the SDK.
+ console.error(e);
+ }
+ }
+ };
+ }
+}
+/**
+ * An implementation of {@link PopupRedirectResolver} suitable for Cordova
+ * based applications.
+ *
+ * @public
+ */
+const cordovaPopupRedirectResolver = CordovaPopupRedirectResolver;
+function generateNoEvent() {
+ return {
+ type: "unknown" /* AuthEventType.UNKNOWN */,
+ eventId: null,
+ sessionId: null,
+ urlResponse: null,
+ postBody: null,
+ tenantId: null,
+ error: index._createError("no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */)
+ };
+}
+
+/**
+ * @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.
+ */
+// This function should only be called by frameworks (e.g. FirebaseUI-web) to log their usage.
+// It is not intended for direct use by developer apps. NO jsdoc here to intentionally leave it out
+// of autogenerated documentation pages to reduce accidental misuse.
+function addFrameworkForLogging(auth, framework) {
+ index._castAuth(auth)._logFramework(framework);
+}
+
+exports.ActionCodeOperation = index.ActionCodeOperation;
+exports.ActionCodeURL = index.ActionCodeURL;
+exports.AuthCredential = index.AuthCredential;
+exports.AuthErrorCodes = index.AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY;
+exports.AuthImpl = index.AuthImpl;
+exports.EmailAuthCredential = index.EmailAuthCredential;
+exports.EmailAuthProvider = index.EmailAuthProvider;
+exports.FacebookAuthProvider = index.FacebookAuthProvider;
+exports.FactorId = index.FactorId;
+exports.FetchProvider = index.FetchProvider;
+exports.GithubAuthProvider = index.GithubAuthProvider;
+exports.GoogleAuthProvider = index.GoogleAuthProvider;
+exports.OAuthCredential = index.OAuthCredential;
+exports.OAuthProvider = index.OAuthProvider;
+exports.OperationType = index.OperationType;
+exports.PhoneAuthCredential = index.PhoneAuthCredential;
+exports.PhoneAuthProvider = index.PhoneAuthProvider;
+exports.PhoneMultiFactorGenerator = index.PhoneMultiFactorGenerator;
+exports.ProviderId = index.ProviderId;
+exports.RecaptchaVerifier = index.RecaptchaVerifier;
+exports.SAMLAuthCredential = index.SAMLAuthCredential;
+exports.SAMLAuthProvider = index.SAMLAuthProvider;
+exports.SignInMethod = index.SignInMethod;
+exports.TotpMultiFactorGenerator = index.TotpMultiFactorGenerator;
+exports.TotpSecret = index.TotpSecret;
+exports.TwitterAuthProvider = index.TwitterAuthProvider;
+exports.UserImpl = index.UserImpl;
+exports._assert = index._assert;
+exports._castAuth = index._castAuth;
+exports._fail = index._fail;
+exports._getClientVersion = index._getClientVersion;
+exports._getInstance = index._getInstance;
+exports._persistenceKeyName = index._persistenceKeyName;
+exports.applyActionCode = index.applyActionCode;
+exports.beforeAuthStateChanged = index.beforeAuthStateChanged;
+exports.checkActionCode = index.checkActionCode;
+exports.confirmPasswordReset = index.confirmPasswordReset;
+exports.connectAuthEmulator = index.connectAuthEmulator;
+exports.createUserWithEmailAndPassword = index.createUserWithEmailAndPassword;
+exports.debugErrorMap = index.debugErrorMap;
+exports.deleteUser = index.deleteUser;
+exports.fetchSignInMethodsForEmail = index.fetchSignInMethodsForEmail;
+exports.getAdditionalUserInfo = index.getAdditionalUserInfo;
+exports.getIdToken = index.getIdToken;
+exports.getIdTokenResult = index.getIdTokenResult;
+exports.getMultiFactorResolver = index.getMultiFactorResolver;
+exports.inMemoryPersistence = index.inMemoryPersistence;
+exports.initializeAuth = index.initializeAuth;
+exports.initializeRecaptchaConfig = index.initializeRecaptchaConfig;
+exports.isSignInWithEmailLink = index.isSignInWithEmailLink;
+exports.linkWithCredential = index.linkWithCredential;
+exports.linkWithPhoneNumber = index.linkWithPhoneNumber;
+exports.multiFactor = index.multiFactor;
+exports.onAuthStateChanged = index.onAuthStateChanged;
+exports.onIdTokenChanged = index.onIdTokenChanged;
+exports.parseActionCodeURL = index.parseActionCodeURL;
+exports.prodErrorMap = index.prodErrorMap;
+exports.reauthenticateWithCredential = index.reauthenticateWithCredential;
+exports.reauthenticateWithPhoneNumber = index.reauthenticateWithPhoneNumber;
+exports.reload = index.reload;
+exports.revokeAccessToken = index.revokeAccessToken;
+exports.sendEmailVerification = index.sendEmailVerification;
+exports.sendPasswordResetEmail = index.sendPasswordResetEmail;
+exports.sendSignInLinkToEmail = index.sendSignInLinkToEmail;
+exports.setPersistence = index.setPersistence;
+exports.signInAnonymously = index.signInAnonymously;
+exports.signInWithCredential = index.signInWithCredential;
+exports.signInWithCustomToken = index.signInWithCustomToken;
+exports.signInWithEmailAndPassword = index.signInWithEmailAndPassword;
+exports.signInWithEmailLink = index.signInWithEmailLink;
+exports.signInWithPhoneNumber = index.signInWithPhoneNumber;
+exports.signOut = index.signOut;
+exports.unlink = index.unlink;
+exports.updateCurrentUser = index.updateCurrentUser;
+exports.updateEmail = index.updateEmail;
+exports.updatePassword = index.updatePassword;
+exports.updatePhoneNumber = index.updatePhoneNumber;
+exports.updateProfile = index.updateProfile;
+exports.useDeviceLanguage = index.useDeviceLanguage;
+exports.validatePassword = index.validatePassword;
+exports.verifyBeforeUpdateEmail = index.verifyBeforeUpdateEmail;
+exports.verifyPasswordResetCode = index.verifyPasswordResetCode;
+exports.AuthPopup = AuthPopup;
+exports._generateEventId = _generateEventId;
+exports._getRedirectResult = _getRedirectResult;
+exports._overrideRedirectResult = _overrideRedirectResult;
+exports.addFrameworkForLogging = addFrameworkForLogging;
+exports.browserCookiePersistence = browserCookiePersistence;
+exports.browserLocalPersistence = browserLocalPersistence;
+exports.browserPopupRedirectResolver = browserPopupRedirectResolver;
+exports.browserSessionPersistence = browserSessionPersistence;
+exports.cordovaPopupRedirectResolver = cordovaPopupRedirectResolver;
+exports.getAuth = getAuth;
+exports.getRedirectResult = getRedirectResult;
+exports.indexedDBLocalPersistence = indexedDBLocalPersistence;
+exports.linkWithPopup = linkWithPopup;
+exports.linkWithRedirect = linkWithRedirect;
+exports.reauthenticateWithPopup = reauthenticateWithPopup;
+exports.reauthenticateWithRedirect = reauthenticateWithRedirect;
+exports.signInWithPopup = signInWithPopup;
+exports.signInWithRedirect = signInWithRedirect;
+//# sourceMappingURL=internal.js.map