johnkim05_obsidian-uuugl-plugin/main.js

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name6 in all)
    __defProp(target, name6, { get: all[name6], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/@firebase/util/dist/postinstall.mjs
var getDefaultsFromPostinstall;
var init_postinstall = __esm({
  "node_modules/@firebase/util/dist/postinstall.mjs"() {
    getDefaultsFromPostinstall = () => void 0;
  }
});

// node_modules/@firebase/util/dist/node-esm/index.node.esm.js
function getGlobal() {
  if (typeof self !== "undefined") {
    return self;
  }
  if (typeof window !== "undefined") {
    return window;
  }
  if (typeof global !== "undefined") {
    return global;
  }
  throw new Error("Unable to locate global object.");
}
function isCloudWorkstation(url) {
  try {
    const host = url.startsWith("http://") || url.startsWith("https://") ? new URL(url).hostname : url;
    return host.endsWith(".cloudworkstations.dev");
  } catch {
    return false;
  }
}
async function pingServer(endpoint) {
  const result = await fetch(endpoint, {
    credentials: "include"
  });
  return result.ok;
}
function createMockUserToken(token, projectId) {
  if (token.uid) {
    throw new Error('The "uid" field is no longer supported by mockUserToken. Please use "sub" instead for Firebase Auth User ID.');
  }
  const header = {
    alg: "none",
    type: "JWT"
  };
  const project = projectId || "demo-project";
  const iat = token.iat || 0;
  const sub = token.sub || token.user_id;
  if (!sub) {
    throw new Error("mockUserToken must contain 'sub' or 'user_id' field!");
  }
  const payload = {
    // Set all required fields to decent defaults
    iss: `https://securetoken.google.com/${project}`,
    aud: project,
    iat,
    exp: iat + 3600,
    auth_time: iat,
    sub,
    user_id: sub,
    firebase: {
      sign_in_provider: "custom",
      identities: {}
    },
    // Override with user options
    ...token
  };
  const signature = "";
  return [
    base64urlEncodeWithoutPadding(JSON.stringify(header)),
    base64urlEncodeWithoutPadding(JSON.stringify(payload)),
    signature
  ].join(".");
}
function getEmulatorSummary() {
  const summary = {
    prod: [],
    emulator: []
  };
  for (const key of Object.keys(emulatorStatus)) {
    if (emulatorStatus[key]) {
      summary.emulator.push(key);
    } else {
      summary.prod.push(key);
    }
  }
  return summary;
}
function getOrCreateEl(id) {
  let parentDiv = document.getElementById(id);
  let created = false;
  if (!parentDiv) {
    parentDiv = document.createElement("div");
    parentDiv.setAttribute("id", id);
    created = true;
  }
  return { created, element: parentDiv };
}
function updateEmulatorBanner(name6, isRunningEmulator) {
  if (typeof window === "undefined" || typeof document === "undefined" || !isCloudWorkstation(window.location.host) || emulatorStatus[name6] === isRunningEmulator || emulatorStatus[name6] || // If already set to use emulator, can't go back to prod.
  previouslyDismissed) {
    return;
  }
  emulatorStatus[name6] = isRunningEmulator;
  function prefixedId(id) {
    return `__firebase__banner__${id}`;
  }
  const bannerId = "__firebase__banner";
  const summary = getEmulatorSummary();
  const showError = summary.prod.length > 0;
  function tearDown() {
    const element = document.getElementById(bannerId);
    if (element) {
      element.remove();
    }
  }
  function setupBannerStyles(bannerEl) {
    bannerEl.style.display = "flex";
    bannerEl.style.background = "#7faaf0";
    bannerEl.style.position = "fixed";
    bannerEl.style.bottom = "5px";
    bannerEl.style.left = "5px";
    bannerEl.style.padding = ".5em";
    bannerEl.style.borderRadius = "5px";
    bannerEl.style.alignItems = "center";
  }
  function setupIconStyles(prependIcon, iconId) {
    prependIcon.setAttribute("width", "24");
    prependIcon.setAttribute("id", iconId);
    prependIcon.setAttribute("height", "24");
    prependIcon.setAttribute("viewBox", "0 0 24 24");
    prependIcon.setAttribute("fill", "none");
    prependIcon.style.marginLeft = "-6px";
  }
  function setupCloseBtn() {
    const closeBtn = document.createElement("span");
    closeBtn.style.cursor = "pointer";
    closeBtn.style.marginLeft = "16px";
    closeBtn.style.fontSize = "24px";
    closeBtn.innerHTML = " ×";
    closeBtn.onclick = () => {
      previouslyDismissed = true;
      tearDown();
    };
    return closeBtn;
  }
  function setupLinkStyles(learnMoreLink, learnMoreId) {
    learnMoreLink.setAttribute("id", learnMoreId);
    learnMoreLink.innerText = "Learn more";
    learnMoreLink.href = "https://firebase.google.com/docs/studio/preview-apps#preview-backend";
    learnMoreLink.setAttribute("target", "__blank");
    learnMoreLink.style.paddingLeft = "5px";
    learnMoreLink.style.textDecoration = "underline";
  }
  function setupDom() {
    const banner = getOrCreateEl(bannerId);
    const firebaseTextId = prefixedId("text");
    const firebaseText = document.getElementById(firebaseTextId) || document.createElement("span");
    const learnMoreId = prefixedId("learnmore");
    const learnMoreLink = document.getElementById(learnMoreId) || document.createElement("a");
    const prependIconId = prefixedId("preprendIcon");
    const prependIcon = document.getElementById(prependIconId) || document.createElementNS("http://www.w3.org/2000/svg", "svg");
    if (banner.created) {
      const bannerEl = banner.element;
      setupBannerStyles(bannerEl);
      setupLinkStyles(learnMoreLink, learnMoreId);
      const closeBtn = setupCloseBtn();
      setupIconStyles(prependIcon, prependIconId);
      bannerEl.append(prependIcon, firebaseText, learnMoreLink, closeBtn);
      document.body.appendChild(bannerEl);
    }
    if (showError) {
      firebaseText.innerText = `Preview backend disconnected.`;
      prependIcon.innerHTML = `<g clip-path="url(#clip0_6013_33858)">
<path d="M4.8 17.6L12 5.6L19.2 17.6H4.8ZM6.91667 16.4H17.0833L12 7.93333L6.91667 16.4ZM12 15.6C12.1667 15.6 12.3056 15.5444 12.4167 15.4333C12.5389 15.3111 12.6 15.1667 12.6 15C12.6 14.8333 12.5389 14.6944 12.4167 14.5833C12.3056 14.4611 12.1667 14.4 12 14.4C11.8333 14.4 11.6889 14.4611 11.5667 14.5833C11.4556 14.6944 11.4 14.8333 11.4 15C11.4 15.1667 11.4556 15.3111 11.5667 15.4333C11.6889 15.5444 11.8333 15.6 12 15.6ZM11.4 13.6H12.6V10.4H11.4V13.6Z" fill="#212121"/>
</g>
<defs>
<clipPath id="clip0_6013_33858">
<rect width="24" height="24" fill="white"/>
</clipPath>
</defs>`;
    } else {
      prependIcon.innerHTML = `<g clip-path="url(#clip0_6083_34804)">
<path d="M11.4 15.2H12.6V11.2H11.4V15.2ZM12 10C12.1667 10 12.3056 9.94444 12.4167 9.83333C12.5389 9.71111 12.6 9.56667 12.6 9.4C12.6 9.23333 12.5389 9.09444 12.4167 8.98333C12.3056 8.86111 12.1667 8.8 12 8.8C11.8333 8.8 11.6889 8.86111 11.5667 8.98333C11.4556 9.09444 11.4 9.23333 11.4 9.4C11.4 9.56667 11.4556 9.71111 11.5667 9.83333C11.6889 9.94444 11.8333 10 12 10ZM12 18.4C11.1222 18.4 10.2944 18.2333 9.51667 17.9C8.73889 17.5667 8.05556 17.1111 7.46667 16.5333C6.88889 15.9444 6.43333 15.2611 6.1 14.4833C5.76667 13.7056 5.6 12.8778 5.6 12C5.6 11.1111 5.76667 10.2833 6.1 9.51667C6.43333 8.73889 6.88889 8.06111 7.46667 7.48333C8.05556 6.89444 8.73889 6.43333 9.51667 6.1C10.2944 5.76667 11.1222 5.6 12 5.6C12.8889 5.6 13.7167 5.76667 14.4833 6.1C15.2611 6.43333 15.9389 6.89444 16.5167 7.48333C17.1056 8.06111 17.5667 8.73889 17.9 9.51667C18.2333 10.2833 18.4 11.1111 18.4 12C18.4 12.8778 18.2333 13.7056 17.9 14.4833C17.5667 15.2611 17.1056 15.9444 16.5167 16.5333C15.9389 17.1111 15.2611 17.5667 14.4833 17.9C13.7167 18.2333 12.8889 18.4 12 18.4ZM12 17.2C13.4444 17.2 14.6722 16.6944 15.6833 15.6833C16.6944 14.6722 17.2 13.4444 17.2 12C17.2 10.5556 16.6944 9.32778 15.6833 8.31667C14.6722 7.30555 13.4444 6.8 12 6.8C10.5556 6.8 9.32778 7.30555 8.31667 8.31667C7.30556 9.32778 6.8 10.5556 6.8 12C6.8 13.4444 7.30556 14.6722 8.31667 15.6833C9.32778 16.6944 10.5556 17.2 12 17.2Z" fill="#212121"/>
</g>
<defs>
<clipPath id="clip0_6083_34804">
<rect width="24" height="24" fill="white"/>
</clipPath>
</defs>`;
      firebaseText.innerText = "Preview backend running in this workspace.";
    }
    firebaseText.setAttribute("id", firebaseTextId);
  }
  if (document.readyState === "loading") {
    window.addEventListener("DOMContentLoaded", setupDom);
  } else {
    setupDom();
  }
}
function getUA() {
  if (typeof navigator !== "undefined" && typeof navigator["userAgent"] === "string") {
    return navigator["userAgent"];
  } else {
    return "";
  }
}
function isMobileCordova() {
  return typeof window !== "undefined" && // @ts-ignore Setting up an broadly applicable index signature for Window
  // just to deal with this case would probably be a bad idea.
  !!(window["cordova"] || window["phonegap"] || window["PhoneGap"]) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA());
}
function isCloudflareWorker() {
  return typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers";
}
function isBrowserExtension() {
  const runtime = typeof chrome === "object" ? chrome.runtime : typeof browser === "object" ? browser.runtime : void 0;
  return typeof runtime === "object" && runtime.id !== void 0;
}
function isReactNative() {
  return typeof navigator === "object" && navigator["product"] === "ReactNative";
}
function isIndexedDBAvailable() {
  try {
    return typeof indexedDB === "object";
  } catch (e) {
    return false;
  }
}
function validateIndexedDBOpenable() {
  return new Promise((resolve, reject) => {
    try {
      let preExist = true;
      const DB_CHECK_NAME = "validate-browser-context-for-indexeddb-analytics-module";
      const request = self.indexedDB.open(DB_CHECK_NAME);
      request.onsuccess = () => {
        request.result.close();
        if (!preExist) {
          self.indexedDB.deleteDatabase(DB_CHECK_NAME);
        }
        resolve(true);
      };
      request.onupgradeneeded = () => {
        preExist = false;
      };
      request.onerror = () => {
        reject(request.error?.message || "");
      };
    } catch (error) {
      reject(error);
    }
  });
}
function replaceTemplate(template, data) {
  return template.replace(PATTERN, (_, key) => {
    const value = data[key];
    return value != null ? String(value) : `<${key}?>`;
  });
}
function deepEqual(a, b) {
  if (a === b) {
    return true;
  }
  const aKeys = Object.keys(a);
  const bKeys = Object.keys(b);
  for (const k of aKeys) {
    if (!bKeys.includes(k)) {
      return false;
    }
    const aProp = a[k];
    const bProp = b[k];
    if (isObject(aProp) && isObject(bProp)) {
      if (!deepEqual(aProp, bProp)) {
        return false;
      }
    } else if (aProp !== bProp) {
      return false;
    }
  }
  for (const k of bKeys) {
    if (!aKeys.includes(k)) {
      return false;
    }
  }
  return true;
}
function isObject(thing) {
  return thing !== null && typeof thing === "object";
}
function querystring(querystringParams) {
  const params = [];
  for (const [key, value] of Object.entries(querystringParams)) {
    if (Array.isArray(value)) {
      value.forEach((arrayVal) => {
        params.push(encodeURIComponent(key) + "=" + encodeURIComponent(arrayVal));
      });
    } else {
      params.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
    }
  }
  return params.length ? "&" + params.join("&") : "";
}
function querystringDecode(querystring2) {
  const obj = {};
  const tokens = querystring2.replace(/^\?/, "").split("&");
  tokens.forEach((token) => {
    if (token) {
      const [key, value] = token.split("=");
      obj[decodeURIComponent(key)] = decodeURIComponent(value);
    }
  });
  return obj;
}
function extractQuerystring(url) {
  const queryStart = url.indexOf("?");
  if (!queryStart) {
    return "";
  }
  const fragmentStart = url.indexOf("#", queryStart);
  return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : void 0);
}
function createSubscribe(executor, onNoObservers) {
  const proxy = new ObserverProxy(executor, onNoObservers);
  return proxy.subscribe.bind(proxy);
}
function implementsAnyMethods(obj, methods) {
  if (typeof obj !== "object" || obj === null) {
    return false;
  }
  for (const method of methods) {
    if (method in obj && typeof obj[method] === "function") {
      return true;
    }
  }
  return false;
}
function noop() {
}
function getModularInstance(service) {
  if (service && service._delegate) {
    return service._delegate;
  } else {
    return service;
  }
}
var CONSTANTS, stringToByteArray$1, byteArrayToString, base64, DecodeBase64StringError, base64Encode, base64urlEncodeWithoutPadding, base64Decode, getDefaultsFromGlobal, getDefaultsFromEnvVariable, getDefaultsFromCookie, getDefaults, getDefaultEmulatorHost, getDefaultEmulatorHostnameAndPort, getDefaultAppConfig, Deferred, emulatorStatus, previouslyDismissed, ERROR_NAME, FirebaseError, ErrorFactory, PATTERN, ObserverProxy, MAX_VALUE_MILLIS;
var init_index_node_esm = __esm({
  "node_modules/@firebase/util/dist/node-esm/index.node.esm.js"() {
    init_postinstall();
    CONSTANTS = {
      /**
       * @define {boolean} Whether this is the client Node.js SDK.
       */
      NODE_CLIENT: false,
      /**
       * @define {boolean} Whether this is the Admin Node.js SDK.
       */
      NODE_ADMIN: false,
      /**
       * Firebase SDK Version
       */
      SDK_VERSION: "${JSCORE_VERSION}"
    };
    stringToByteArray$1 = function(str) {
      const out = [];
      let p = 0;
      for (let i = 0; i < str.length; i++) {
        let c = str.charCodeAt(i);
        if (c < 128) {
          out[p++] = c;
        } else if (c < 2048) {
          out[p++] = c >> 6 | 192;
          out[p++] = c & 63 | 128;
        } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
          c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
          out[p++] = c >> 18 | 240;
          out[p++] = c >> 12 & 63 | 128;
          out[p++] = c >> 6 & 63 | 128;
          out[p++] = c & 63 | 128;
        } else {
          out[p++] = c >> 12 | 224;
          out[p++] = c >> 6 & 63 | 128;
          out[p++] = c & 63 | 128;
        }
      }
      return out;
    };
    byteArrayToString = function(bytes) {
      const out = [];
      let pos = 0, c = 0;
      while (pos < bytes.length) {
        const c1 = bytes[pos++];
        if (c1 < 128) {
          out[c++] = String.fromCharCode(c1);
        } else if (c1 > 191 && c1 < 224) {
          const c2 = bytes[pos++];
          out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
        } else if (c1 > 239 && c1 < 365) {
          const c2 = bytes[pos++];
          const c3 = bytes[pos++];
          const c4 = bytes[pos++];
          const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
          out[c++] = String.fromCharCode(55296 + (u >> 10));
          out[c++] = String.fromCharCode(56320 + (u & 1023));
        } else {
          const c2 = bytes[pos++];
          const c3 = bytes[pos++];
          out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
        }
      }
      return out.join("");
    };
    base64 = {
      /**
       * Maps bytes to characters.
       */
      byteToCharMap_: null,
      /**
       * Maps characters to bytes.
       */
      charToByteMap_: null,
      /**
       * Maps bytes to websafe characters.
       * @private
       */
      byteToCharMapWebSafe_: null,
      /**
       * Maps websafe characters to bytes.
       * @private
       */
      charToByteMapWebSafe_: null,
      /**
       * Our default alphabet, shared between
       * ENCODED_VALS and ENCODED_VALS_WEBSAFE
       */
      ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
      /**
       * Our default alphabet. Value 64 (=) is special; it means "nothing."
       */
      get ENCODED_VALS() {
        return this.ENCODED_VALS_BASE + "+/=";
      },
      /**
       * Our websafe alphabet.
       */
      get ENCODED_VALS_WEBSAFE() {
        return this.ENCODED_VALS_BASE + "-_.";
      },
      /**
       * Whether this browser supports the atob and btoa functions. This extension
       * started at Mozilla but is now implemented by many browsers. We use the
       * ASSUME_* variables to avoid pulling in the full useragent detection library
       * but still allowing the standard per-browser compilations.
       *
       */
      HAS_NATIVE_SUPPORT: typeof atob === "function",
      /**
       * Base64-encode an array of bytes.
       *
       * @param input An array of bytes (numbers with
       *     value in [0, 255]) to encode.
       * @param webSafe Boolean indicating we should use the
       *     alternative alphabet.
       * @return The base64 encoded string.
       */
      encodeByteArray(input, webSafe) {
        if (!Array.isArray(input)) {
          throw Error("encodeByteArray takes an array as a parameter");
        }
        this.init_();
        const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
        const output = [];
        for (let i = 0; i < input.length; i += 3) {
          const byte1 = input[i];
          const haveByte2 = i + 1 < input.length;
          const byte2 = haveByte2 ? input[i + 1] : 0;
          const haveByte3 = i + 2 < input.length;
          const byte3 = haveByte3 ? input[i + 2] : 0;
          const outByte1 = byte1 >> 2;
          const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
          let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
          let outByte4 = byte3 & 63;
          if (!haveByte3) {
            outByte4 = 64;
            if (!haveByte2) {
              outByte3 = 64;
            }
          }
          output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
        }
        return output.join("");
      },
      /**
       * Base64-encode a string.
       *
       * @param input A string to encode.
       * @param webSafe If true, we should use the
       *     alternative alphabet.
       * @return The base64 encoded string.
       */
      encodeString(input, webSafe) {
        if (this.HAS_NATIVE_SUPPORT && !webSafe) {
          return btoa(input);
        }
        return this.encodeByteArray(stringToByteArray$1(input), webSafe);
      },
      /**
       * Base64-decode a string.
       *
       * @param input to decode.
       * @param webSafe True if we should use the
       *     alternative alphabet.
       * @return string representing the decoded value.
       */
      decodeString(input, webSafe) {
        if (this.HAS_NATIVE_SUPPORT && !webSafe) {
          return atob(input);
        }
        return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
      },
      /**
       * Base64-decode a string.
       *
       * In base-64 decoding, groups of four characters are converted into three
       * bytes.  If the encoder did not apply padding, the input length may not
       * be a multiple of 4.
       *
       * In this case, the last group will have fewer than 4 characters, and
       * padding will be inferred.  If the group has one or two characters, it decodes
       * to one byte.  If the group has three characters, it decodes to two bytes.
       *
       * @param input Input to decode.
       * @param webSafe True if we should use the web-safe alphabet.
       * @return bytes representing the decoded value.
       */
      decodeStringToByteArray(input, webSafe) {
        this.init_();
        const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
        const output = [];
        for (let i = 0; i < input.length; ) {
          const byte1 = charToByteMap[input.charAt(i++)];
          const haveByte2 = i < input.length;
          const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
          ++i;
          const haveByte3 = i < input.length;
          const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
          ++i;
          const haveByte4 = i < input.length;
          const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
          ++i;
          if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
            throw new DecodeBase64StringError();
          }
          const outByte1 = byte1 << 2 | byte2 >> 4;
          output.push(outByte1);
          if (byte3 !== 64) {
            const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
            output.push(outByte2);
            if (byte4 !== 64) {
              const outByte3 = byte3 << 6 & 192 | byte4;
              output.push(outByte3);
            }
          }
        }
        return output;
      },
      /**
       * Lazy static initialization function. Called before
       * accessing any of the static map variables.
       * @private
       */
      init_() {
        if (!this.byteToCharMap_) {
          this.byteToCharMap_ = {};
          this.charToByteMap_ = {};
          this.byteToCharMapWebSafe_ = {};
          this.charToByteMapWebSafe_ = {};
          for (let i = 0; i < this.ENCODED_VALS.length; i++) {
            this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
            this.charToByteMap_[this.byteToCharMap_[i]] = i;
            this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
            this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
            if (i >= this.ENCODED_VALS_BASE.length) {
              this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
              this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
            }
          }
        }
      }
    };
    DecodeBase64StringError = class extends Error {
      constructor() {
        super(...arguments);
        this.name = "DecodeBase64StringError";
      }
    };
    base64Encode = function(str) {
      const utf8Bytes = stringToByteArray$1(str);
      return base64.encodeByteArray(utf8Bytes, true);
    };
    base64urlEncodeWithoutPadding = function(str) {
      return base64Encode(str).replace(/\./g, "");
    };
    base64Decode = function(str) {
      try {
        return base64.decodeString(str, true);
      } catch (e) {
        console.error("base64Decode failed: ", e);
      }
      return null;
    };
    getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;
    getDefaultsFromEnvVariable = () => {
      if (typeof process === "undefined" || typeof process.env === "undefined") {
        return;
      }
      const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;
      if (defaultsJsonString) {
        return JSON.parse(defaultsJsonString);
      }
    };
    getDefaultsFromCookie = () => {
      if (typeof document === "undefined") {
        return;
      }
      let match;
      try {
        match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
      } catch (e) {
        return;
      }
      const decoded = match && base64Decode(match[1]);
      return decoded && JSON.parse(decoded);
    };
    getDefaults = () => {
      try {
        return getDefaultsFromPostinstall() || getDefaultsFromGlobal() || getDefaultsFromEnvVariable() || getDefaultsFromCookie();
      } catch (e) {
        console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);
        return;
      }
    };
    getDefaultEmulatorHost = (productName) => getDefaults()?.emulatorHosts?.[productName];
    getDefaultEmulatorHostnameAndPort = (productName) => {
      const host = getDefaultEmulatorHost(productName);
      if (!host) {
        return void 0;
      }
      const separatorIndex = host.lastIndexOf(":");
      if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {
        throw new Error(`Invalid host ${host} with no separate hostname and port!`);
      }
      const port = parseInt(host.substring(separatorIndex + 1), 10);
      if (host[0] === "[") {
        return [host.substring(1, separatorIndex - 1), port];
      } else {
        return [host.substring(0, separatorIndex), port];
      }
    };
    getDefaultAppConfig = () => getDefaults()?.config;
    Deferred = class {
      constructor() {
        this.reject = () => {
        };
        this.resolve = () => {
        };
        this.promise = new Promise((resolve, reject) => {
          this.resolve = resolve;
          this.reject = reject;
        });
      }
      /**
       * Our API internals are not promisified and cannot because our callback APIs have subtle expectations around
       * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback
       * and returns a node-style callback which will resolve or reject the Deferred's promise.
       */
      wrapCallback(callback) {
        return (error, value) => {
          if (error) {
            this.reject(error);
          } else {
            this.resolve(value);
          }
          if (typeof callback === "function") {
            this.promise.catch(() => {
            });
            if (callback.length === 1) {
              callback(error);
            } else {
              callback(error, value);
            }
          }
        };
      }
    };
    emulatorStatus = {};
    previouslyDismissed = false;
    ERROR_NAME = "FirebaseError";
    FirebaseError = class _FirebaseError extends Error {
      constructor(code, message, customData) {
        super(message);
        this.code = code;
        this.customData = customData;
        this.name = ERROR_NAME;
        Object.setPrototypeOf(this, _FirebaseError.prototype);
        if (Error.captureStackTrace) {
          Error.captureStackTrace(this, ErrorFactory.prototype.create);
        }
      }
    };
    ErrorFactory = class {
      constructor(service, serviceName, errors) {
        this.service = service;
        this.serviceName = serviceName;
        this.errors = errors;
      }
      create(code, ...data) {
        const customData = data[0] || {};
        const fullCode = `${this.service}/${code}`;
        const template = this.errors[code];
        const message = template ? replaceTemplate(template, customData) : "Error";
        const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;
        const error = new FirebaseError(fullCode, fullMessage, customData);
        return error;
      }
    };
    PATTERN = /\{\$([^}]+)}/g;
    ObserverProxy = class {
      /**
       * @param executor Function which can make calls to a single Observer
       *     as a proxy.
       * @param onNoObservers Callback when count of Observers goes to zero.
       */
      constructor(executor, onNoObservers) {
        this.observers = [];
        this.unsubscribes = [];
        this.observerCount = 0;
        this.task = Promise.resolve();
        this.finalized = false;
        this.onNoObservers = onNoObservers;
        this.task.then(() => {
          executor(this);
        }).catch((e) => {
          this.error(e);
        });
      }
      next(value) {
        this.forEachObserver((observer) => {
          observer.next(value);
        });
      }
      error(error) {
        this.forEachObserver((observer) => {
          observer.error(error);
        });
        this.close(error);
      }
      complete() {
        this.forEachObserver((observer) => {
          observer.complete();
        });
        this.close();
      }
      /**
       * Subscribe function that can be used to add an Observer to the fan-out list.
       *
       * - We require that no event is sent to a subscriber synchronously to their
       *   call to subscribe().
       */
      subscribe(nextOrObserver, error, complete) {
        let observer;
        if (nextOrObserver === void 0 && error === void 0 && complete === void 0) {
          throw new Error("Missing Observer.");
        }
        if (implementsAnyMethods(nextOrObserver, [
          "next",
          "error",
          "complete"
        ])) {
          observer = nextOrObserver;
        } else {
          observer = {
            next: nextOrObserver,
            error,
            complete
          };
        }
        if (observer.next === void 0) {
          observer.next = noop;
        }
        if (observer.error === void 0) {
          observer.error = noop;
        }
        if (observer.complete === void 0) {
          observer.complete = noop;
        }
        const unsub = this.unsubscribeOne.bind(this, this.observers.length);
        if (this.finalized) {
          this.task.then(() => {
            try {
              if (this.finalError) {
                observer.error(this.finalError);
              } else {
                observer.complete();
              }
            } catch (e) {
            }
            return;
          });
        }
        this.observers.push(observer);
        return unsub;
      }
      // Unsubscribe is synchronous - we guarantee that no events are sent to
      // any unsubscribed Observer.
      unsubscribeOne(i) {
        if (this.observers === void 0 || this.observers[i] === void 0) {
          return;
        }
        delete this.observers[i];
        this.observerCount -= 1;
        if (this.observerCount === 0 && this.onNoObservers !== void 0) {
          this.onNoObservers(this);
        }
      }
      forEachObserver(fn) {
        if (this.finalized) {
          return;
        }
        for (let i = 0; i < this.observers.length; i++) {
          this.sendOne(i, fn);
        }
      }
      // Call the Observer via one of it's callback function. We are careful to
      // confirm that the observe has not been unsubscribed since this asynchronous
      // function had been queued.
      sendOne(i, fn) {
        this.task.then(() => {
          if (this.observers !== void 0 && this.observers[i] !== void 0) {
            try {
              fn(this.observers[i]);
            } catch (e) {
              if (typeof console !== "undefined" && console.error) {
                console.error(e);
              }
            }
          }
        });
      }
      close(err) {
        if (this.finalized) {
          return;
        }
        this.finalized = true;
        if (err !== void 0) {
          this.finalError = err;
        }
        this.task.then(() => {
          this.observers = void 0;
          this.onNoObservers = void 0;
        });
      }
    };
    MAX_VALUE_MILLIS = 4 * 60 * 60 * 1e3;
    CONSTANTS.NODE_CLIENT = true;
  }
});

// node_modules/@firebase/component/dist/esm/index.esm.js
function normalizeIdentifierForFactory(identifier) {
  return identifier === DEFAULT_ENTRY_NAME ? void 0 : identifier;
}
function isComponentEager(component) {
  return component.instantiationMode === "EAGER";
}
var Component, DEFAULT_ENTRY_NAME, Provider, ComponentContainer;
var init_index_esm = __esm({
  "node_modules/@firebase/component/dist/esm/index.esm.js"() {
    init_index_node_esm();
    Component = class {
      /**
       *
       * @param name The public service name, e.g. app, auth, firestore, database
       * @param instanceFactory Service factory responsible for creating the public interface
       * @param type whether the service provided by the component is public or private
       */
      constructor(name6, instanceFactory, type) {
        this.name = name6;
        this.instanceFactory = instanceFactory;
        this.type = type;
        this.multipleInstances = false;
        this.serviceProps = {};
        this.instantiationMode = "LAZY";
        this.onInstanceCreated = null;
      }
      setInstantiationMode(mode) {
        this.instantiationMode = mode;
        return this;
      }
      setMultipleInstances(multipleInstances) {
        this.multipleInstances = multipleInstances;
        return this;
      }
      setServiceProps(props) {
        this.serviceProps = props;
        return this;
      }
      setInstanceCreatedCallback(callback) {
        this.onInstanceCreated = callback;
        return this;
      }
    };
    DEFAULT_ENTRY_NAME = "[DEFAULT]";
    Provider = class {
      constructor(name6, container) {
        this.name = name6;
        this.container = container;
        this.component = null;
        this.instances = /* @__PURE__ */ new Map();
        this.instancesDeferred = /* @__PURE__ */ new Map();
        this.instancesOptions = /* @__PURE__ */ new Map();
        this.onInitCallbacks = /* @__PURE__ */ new Map();
      }
      /**
       * @param identifier A provider can provide multiple instances of a service
       * if this.component.multipleInstances is true.
       */
      get(identifier) {
        const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
        if (!this.instancesDeferred.has(normalizedIdentifier)) {
          const deferred = new Deferred();
          this.instancesDeferred.set(normalizedIdentifier, deferred);
          if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
            try {
              const instance = this.getOrInitializeService({
                instanceIdentifier: normalizedIdentifier
              });
              if (instance) {
                deferred.resolve(instance);
              }
            } catch (e) {
            }
          }
        }
        return this.instancesDeferred.get(normalizedIdentifier).promise;
      }
      getImmediate(options) {
        const normalizedIdentifier = this.normalizeInstanceIdentifier(options?.identifier);
        const optional = options?.optional ?? false;
        if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
          try {
            return this.getOrInitializeService({
              instanceIdentifier: normalizedIdentifier
            });
          } catch (e) {
            if (optional) {
              return null;
            } else {
              throw e;
            }
          }
        } else {
          if (optional) {
            return null;
          } else {
            throw Error(`Service ${this.name} is not available`);
          }
        }
      }
      getComponent() {
        return this.component;
      }
      setComponent(component) {
        if (component.name !== this.name) {
          throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
        }
        if (this.component) {
          throw Error(`Component for ${this.name} has already been provided`);
        }
        this.component = component;
        if (!this.shouldAutoInitialize()) {
          return;
        }
        if (isComponentEager(component)) {
          try {
            this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });
          } catch (e) {
          }
        }
        for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
          const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
          try {
            const instance = this.getOrInitializeService({
              instanceIdentifier: normalizedIdentifier
            });
            instanceDeferred.resolve(instance);
          } catch (e) {
          }
        }
      }
      clearInstance(identifier = DEFAULT_ENTRY_NAME) {
        this.instancesDeferred.delete(identifier);
        this.instancesOptions.delete(identifier);
        this.instances.delete(identifier);
      }
      // app.delete() will call this method on every provider to delete the services
      // TODO: should we mark the provider as deleted?
      async delete() {
        const services = Array.from(this.instances.values());
        await Promise.all([
          ...services.filter((service) => "INTERNAL" in service).map((service) => service.INTERNAL.delete()),
          ...services.filter((service) => "_delete" in service).map((service) => service._delete())
        ]);
      }
      isComponentSet() {
        return this.component != null;
      }
      isInitialized(identifier = DEFAULT_ENTRY_NAME) {
        return this.instances.has(identifier);
      }
      getOptions(identifier = DEFAULT_ENTRY_NAME) {
        return this.instancesOptions.get(identifier) || {};
      }
      initialize(opts = {}) {
        const { options = {} } = opts;
        const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
        if (this.isInitialized(normalizedIdentifier)) {
          throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
        }
        if (!this.isComponentSet()) {
          throw Error(`Component ${this.name} has not been registered yet`);
        }
        const instance = this.getOrInitializeService({
          instanceIdentifier: normalizedIdentifier,
          options
        });
        for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
          const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
          if (normalizedIdentifier === normalizedDeferredIdentifier) {
            instanceDeferred.resolve(instance);
          }
        }
        return instance;
      }
      /**
       *
       * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().
       * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.
       *
       * @param identifier An optional instance identifier
       * @returns a function to unregister the callback
       */
      onInit(callback, identifier) {
        const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
        const existingCallbacks = this.onInitCallbacks.get(normalizedIdentifier) ?? /* @__PURE__ */ new Set();
        existingCallbacks.add(callback);
        this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
        const existingInstance = this.instances.get(normalizedIdentifier);
        if (existingInstance) {
          callback(existingInstance, normalizedIdentifier);
        }
        return () => {
          existingCallbacks.delete(callback);
        };
      }
      /**
       * Invoke onInit callbacks synchronously
       * @param instance the service instance`
       */
      invokeOnInitCallbacks(instance, identifier) {
        const callbacks = this.onInitCallbacks.get(identifier);
        if (!callbacks) {
          return;
        }
        for (const callback of callbacks) {
          try {
            callback(instance, identifier);
          } catch {
          }
        }
      }
      getOrInitializeService({ instanceIdentifier, options = {} }) {
        let instance = this.instances.get(instanceIdentifier);
        if (!instance && this.component) {
          instance = this.component.instanceFactory(this.container, {
            instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),
            options
          });
          this.instances.set(instanceIdentifier, instance);
          this.instancesOptions.set(instanceIdentifier, options);
          this.invokeOnInitCallbacks(instance, instanceIdentifier);
          if (this.component.onInstanceCreated) {
            try {
              this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
            } catch {
            }
          }
        }
        return instance || null;
      }
      normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME) {
        if (this.component) {
          return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;
        } else {
          return identifier;
        }
      }
      shouldAutoInitialize() {
        return !!this.component && this.component.instantiationMode !== "EXPLICIT";
      }
    };
    ComponentContainer = class {
      constructor(name6) {
        this.name = name6;
        this.providers = /* @__PURE__ */ new Map();
      }
      /**
       *
       * @param component Component being added
       * @param overwrite When a component with the same name has already been registered,
       * if overwrite is true: overwrite the existing component with the new component and create a new
       * provider with the new component. It can be useful in tests where you want to use different mocks
       * for different tests.
       * if overwrite is false: throw an exception
       */
      addComponent(component) {
        const provider = this.getProvider(component.name);
        if (provider.isComponentSet()) {
          throw new Error(`Component ${component.name} has already been registered with ${this.name}`);
        }
        provider.setComponent(component);
      }
      addOrOverwriteComponent(component) {
        const provider = this.getProvider(component.name);
        if (provider.isComponentSet()) {
          this.providers.delete(component.name);
        }
        this.addComponent(component);
      }
      /**
       * getProvider provides a type safe interface where it can only be called with a field name
       * present in NameServiceMapping interface.
       *
       * Firebase SDKs providing services should extend NameServiceMapping interface to register
       * themselves.
       */
      getProvider(name6) {
        if (this.providers.has(name6)) {
          return this.providers.get(name6);
        }
        const provider = new Provider(name6, this);
        this.providers.set(name6, provider);
        return provider;
      }
      getProviders() {
        return Array.from(this.providers.values());
      }
    };
  }
});

// node_modules/@firebase/logger/dist/esm/index.esm.js
var instances, LogLevel, levelStringToEnum, defaultLogLevel, ConsoleMethod, defaultLogHandler, Logger;
var init_index_esm2 = __esm({
  "node_modules/@firebase/logger/dist/esm/index.esm.js"() {
    instances = [];
    (function(LogLevel2) {
      LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
      LogLevel2[LogLevel2["VERBOSE"] = 1] = "VERBOSE";
      LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
      LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
      LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
      LogLevel2[LogLevel2["SILENT"] = 5] = "SILENT";
    })(LogLevel || (LogLevel = {}));
    levelStringToEnum = {
      "debug": LogLevel.DEBUG,
      "verbose": LogLevel.VERBOSE,
      "info": LogLevel.INFO,
      "warn": LogLevel.WARN,
      "error": LogLevel.ERROR,
      "silent": LogLevel.SILENT
    };
    defaultLogLevel = LogLevel.INFO;
    ConsoleMethod = {
      [LogLevel.DEBUG]: "log",
      [LogLevel.VERBOSE]: "log",
      [LogLevel.INFO]: "info",
      [LogLevel.WARN]: "warn",
      [LogLevel.ERROR]: "error"
    };
    defaultLogHandler = (instance, logType, ...args) => {
      if (logType < instance.logLevel) {
        return;
      }
      const now = (/* @__PURE__ */ new Date()).toISOString();
      const method = ConsoleMethod[logType];
      if (method) {
        console[method](`[${now}]  ${instance.name}:`, ...args);
      } else {
        throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
      }
    };
    Logger = class {
      /**
       * Gives you an instance of a Logger to capture messages according to
       * Firebase's logging scheme.
       *
       * @param name The name that the logs will be associated with
       */
      constructor(name6) {
        this.name = name6;
        this._logLevel = defaultLogLevel;
        this._logHandler = defaultLogHandler;
        this._userLogHandler = null;
        instances.push(this);
      }
      get logLevel() {
        return this._logLevel;
      }
      set logLevel(val) {
        if (!(val in LogLevel)) {
          throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
        }
        this._logLevel = val;
      }
      // Workaround for setter/getter having to be the same type.
      setLogLevel(val) {
        this._logLevel = typeof val === "string" ? levelStringToEnum[val] : val;
      }
      get logHandler() {
        return this._logHandler;
      }
      set logHandler(val) {
        if (typeof val !== "function") {
          throw new TypeError("Value assigned to `logHandler` must be a function");
        }
        this._logHandler = val;
      }
      get userLogHandler() {
        return this._userLogHandler;
      }
      set userLogHandler(val) {
        this._userLogHandler = val;
      }
      /**
       * The functions below are all based on the `console` interface
       */
      debug(...args) {
        this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
        this._logHandler(this, LogLevel.DEBUG, ...args);
      }
      log(...args) {
        this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);
        this._logHandler(this, LogLevel.VERBOSE, ...args);
      }
      info(...args) {
        this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
        this._logHandler(this, LogLevel.INFO, ...args);
      }
      warn(...args) {
        this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
        this._logHandler(this, LogLevel.WARN, ...args);
      }
      error(...args) {
        this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
        this._logHandler(this, LogLevel.ERROR, ...args);
      }
    };
  }
});

// node_modules/idb/build/wrap-idb-value.js
function getIdbProxyableTypes() {
  return idbProxyableTypes || (idbProxyableTypes = [
    IDBDatabase,
    IDBObjectStore,
    IDBIndex,
    IDBCursor,
    IDBTransaction
  ]);
}
function getCursorAdvanceMethods() {
  return cursorAdvanceMethods || (cursorAdvanceMethods = [
    IDBCursor.prototype.advance,
    IDBCursor.prototype.continue,
    IDBCursor.prototype.continuePrimaryKey
  ]);
}
function promisifyRequest(request) {
  const promise = new Promise((resolve, reject) => {
    const unlisten = () => {
      request.removeEventListener("success", success);
      request.removeEventListener("error", error);
    };
    const success = () => {
      resolve(wrap(request.result));
      unlisten();
    };
    const error = () => {
      reject(request.error);
      unlisten();
    };
    request.addEventListener("success", success);
    request.addEventListener("error", error);
  });
  promise.then((value) => {
    if (value instanceof IDBCursor) {
      cursorRequestMap.set(value, request);
    }
  }).catch(() => {
  });
  reverseTransformCache.set(promise, request);
  return promise;
}
function cacheDonePromiseForTransaction(tx) {
  if (transactionDoneMap.has(tx))
    return;
  const done = new Promise((resolve, reject) => {
    const unlisten = () => {
      tx.removeEventListener("complete", complete);
      tx.removeEventListener("error", error);
      tx.removeEventListener("abort", error);
    };
    const complete = () => {
      resolve();
      unlisten();
    };
    const error = () => {
      reject(tx.error || new DOMException("AbortError", "AbortError"));
      unlisten();
    };
    tx.addEventListener("complete", complete);
    tx.addEventListener("error", error);
    tx.addEventListener("abort", error);
  });
  transactionDoneMap.set(tx, done);
}
function replaceTraps(callback) {
  idbProxyTraps = callback(idbProxyTraps);
}
function wrapFunction(func) {
  if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
    return function(storeNames, ...args) {
      const tx = func.call(unwrap(this), storeNames, ...args);
      transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
      return wrap(tx);
    };
  }
  if (getCursorAdvanceMethods().includes(func)) {
    return function(...args) {
      func.apply(unwrap(this), args);
      return wrap(cursorRequestMap.get(this));
    };
  }
  return function(...args) {
    return wrap(func.apply(unwrap(this), args));
  };
}
function transformCachableValue(value) {
  if (typeof value === "function")
    return wrapFunction(value);
  if (value instanceof IDBTransaction)
    cacheDonePromiseForTransaction(value);
  if (instanceOfAny(value, getIdbProxyableTypes()))
    return new Proxy(value, idbProxyTraps);
  return value;
}
function wrap(value) {
  if (value instanceof IDBRequest)
    return promisifyRequest(value);
  if (transformCache.has(value))
    return transformCache.get(value);
  const newValue = transformCachableValue(value);
  if (newValue !== value) {
    transformCache.set(value, newValue);
    reverseTransformCache.set(newValue, value);
  }
  return newValue;
}
var instanceOfAny, idbProxyableTypes, cursorAdvanceMethods, cursorRequestMap, transactionDoneMap, transactionStoreNamesMap, transformCache, reverseTransformCache, idbProxyTraps, unwrap;
var init_wrap_idb_value = __esm({
  "node_modules/idb/build/wrap-idb-value.js"() {
    instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
    cursorRequestMap = /* @__PURE__ */ new WeakMap();
    transactionDoneMap = /* @__PURE__ */ new WeakMap();
    transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
    transformCache = /* @__PURE__ */ new WeakMap();
    reverseTransformCache = /* @__PURE__ */ new WeakMap();
    idbProxyTraps = {
      get(target, prop, receiver) {
        if (target instanceof IDBTransaction) {
          if (prop === "done")
            return transactionDoneMap.get(target);
          if (prop === "objectStoreNames") {
            return target.objectStoreNames || transactionStoreNamesMap.get(target);
          }
          if (prop === "store") {
            return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
          }
        }
        return wrap(target[prop]);
      },
      set(target, prop, value) {
        target[prop] = value;
        return true;
      },
      has(target, prop) {
        if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
          return true;
        }
        return prop in target;
      }
    };
    unwrap = (value) => reverseTransformCache.get(value);
  }
});

// node_modules/idb/build/index.js
var build_exports = {};
__export(build_exports, {
  deleteDB: () => deleteDB,
  openDB: () => openDB,
  unwrap: () => unwrap,
  wrap: () => wrap
});
function openDB(name6, version6, { blocked, upgrade, blocking, terminated } = {}) {
  const request = indexedDB.open(name6, version6);
  const openPromise = wrap(request);
  if (upgrade) {
    request.addEventListener("upgradeneeded", (event) => {
      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
    });
  }
  if (blocked) {
    request.addEventListener("blocked", (event) => blocked(
      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
      event.oldVersion,
      event.newVersion,
      event
    ));
  }
  openPromise.then((db) => {
    if (terminated)
      db.addEventListener("close", () => terminated());
    if (blocking) {
      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
    }
  }).catch(() => {
  });
  return openPromise;
}
function deleteDB(name6, { blocked } = {}) {
  const request = indexedDB.deleteDatabase(name6);
  if (blocked) {
    request.addEventListener("blocked", (event) => blocked(
      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
      event.oldVersion,
      event
    ));
  }
  return wrap(request).then(() => void 0);
}
function getMethod(target, prop) {
  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
    return;
  }
  if (cachedMethods.get(prop))
    return cachedMethods.get(prop);
  const targetFuncName = prop.replace(/FromIndex$/, "");
  const useIndex = prop !== targetFuncName;
  const isWrite = writeMethods.includes(targetFuncName);
  if (
    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))
  ) {
    return;
  }
  const method = async function(storeName, ...args) {
    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
    let target2 = tx.store;
    if (useIndex)
      target2 = target2.index(args.shift());
    return (await Promise.all([
      target2[targetFuncName](...args),
      isWrite && tx.done
    ]))[0];
  };
  cachedMethods.set(prop, method);
  return method;
}
var readMethods, writeMethods, cachedMethods;
var init_build = __esm({
  "node_modules/idb/build/index.js"() {
    init_wrap_idb_value();
    init_wrap_idb_value();
    readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
    writeMethods = ["put", "add", "delete", "clear"];
    cachedMethods = /* @__PURE__ */ new Map();
    replaceTraps((oldTraps) => ({
      ...oldTraps,
      get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
      has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
    }));
  }
});

// node_modules/@firebase/app/dist/esm/index.esm.js
function isVersionServiceProvider(provider) {
  const component = provider.getComponent();
  return component?.type === "VERSION";
}
function _addComponent(app2, component) {
  try {
    app2.container.addComponent(component);
  } catch (e) {
    logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app2.name}`, e);
  }
}
function _registerComponent(component) {
  const componentName = component.name;
  if (_components.has(componentName)) {
    logger.debug(`There were multiple attempts to register component ${componentName}.`);
    return false;
  }
  _components.set(componentName, component);
  for (const app2 of _apps.values()) {
    _addComponent(app2, component);
  }
  for (const serverApp of _serverApps.values()) {
    _addComponent(serverApp, component);
  }
  return true;
}
function _getProvider(app2, name6) {
  const heartbeatController = app2.container.getProvider("heartbeat").getImmediate({ optional: true });
  if (heartbeatController) {
    void heartbeatController.triggerHeartbeat();
  }
  return app2.container.getProvider(name6);
}
function _isFirebaseServerApp(obj) {
  if (obj === null || obj === void 0) {
    return false;
  }
  return obj.settings !== void 0;
}
function initializeApp(_options, rawConfig = {}) {
  let options = _options;
  if (typeof rawConfig !== "object") {
    const name7 = rawConfig;
    rawConfig = { name: name7 };
  }
  const config = {
    name: DEFAULT_ENTRY_NAME2,
    automaticDataCollectionEnabled: true,
    ...rawConfig
  };
  const name6 = config.name;
  if (typeof name6 !== "string" || !name6) {
    throw ERROR_FACTORY.create("bad-app-name", {
      appName: String(name6)
    });
  }
  options || (options = getDefaultAppConfig());
  if (!options) {
    throw ERROR_FACTORY.create(
      "no-options"
      /* AppError.NO_OPTIONS */
    );
  }
  const existingApp = _apps.get(name6);
  if (existingApp) {
    if (deepEqual(options, existingApp.options) && deepEqual(config, existingApp.config)) {
      return existingApp;
    } else {
      throw ERROR_FACTORY.create("duplicate-app", { appName: name6 });
    }
  }
  const container = new ComponentContainer(name6);
  for (const component of _components.values()) {
    container.addComponent(component);
  }
  const newApp = new FirebaseAppImpl(options, config, container);
  _apps.set(name6, newApp);
  return newApp;
}
function getApp(name6 = DEFAULT_ENTRY_NAME2) {
  const app2 = _apps.get(name6);
  if (!app2 && name6 === DEFAULT_ENTRY_NAME2 && getDefaultAppConfig()) {
    return initializeApp();
  }
  if (!app2) {
    throw ERROR_FACTORY.create("no-app", { appName: name6 });
  }
  return app2;
}
function registerVersion(libraryKeyOrName, version6, variant) {
  let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? libraryKeyOrName;
  if (variant) {
    library += `-${variant}`;
  }
  const libraryMismatch = library.match(/\s|\//);
  const versionMismatch = version6.match(/\s|\//);
  if (libraryMismatch || versionMismatch) {
    const warning = [
      `Unable to register library "${library}" with version "${version6}":`
    ];
    if (libraryMismatch) {
      warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
    }
    if (libraryMismatch && versionMismatch) {
      warning.push("and");
    }
    if (versionMismatch) {
      warning.push(`version name "${version6}" contains illegal characters (whitespace or "/")`);
    }
    logger.warn(warning.join(" "));
    return;
  }
  _registerComponent(new Component(
    `${library}-version`,
    () => ({ library, version: version6 }),
    "VERSION"
    /* ComponentType.VERSION */
  ));
}
function getDbPromise() {
  if (!dbPromise) {
    dbPromise = openDB(DB_NAME, DB_VERSION, {
      upgrade: (db, oldVersion) => {
        switch (oldVersion) {
          case 0:
            try {
              db.createObjectStore(STORE_NAME);
            } catch (e) {
              console.warn(e);
            }
        }
      }
    }).catch((e) => {
      throw ERROR_FACTORY.create("idb-open", {
        originalErrorMessage: e.message
      });
    });
  }
  return dbPromise;
}
async function readHeartbeatsFromIndexedDB(app2) {
  try {
    const db = await getDbPromise();
    const tx = db.transaction(STORE_NAME);
    const result = await tx.objectStore(STORE_NAME).get(computeKey(app2));
    await tx.done;
    return result;
  } catch (e) {
    if (e instanceof FirebaseError) {
      logger.warn(e.message);
    } else {
      const idbGetError = ERROR_FACTORY.create("idb-get", {
        originalErrorMessage: e?.message
      });
      logger.warn(idbGetError.message);
    }
  }
}
async function writeHeartbeatsToIndexedDB(app2, heartbeatObject) {
  try {
    const db = await getDbPromise();
    const tx = db.transaction(STORE_NAME, "readwrite");
    const objectStore = tx.objectStore(STORE_NAME);
    await objectStore.put(heartbeatObject, computeKey(app2));
    await tx.done;
  } catch (e) {
    if (e instanceof FirebaseError) {
      logger.warn(e.message);
    } else {
      const idbGetError = ERROR_FACTORY.create("idb-set", {
        originalErrorMessage: e?.message
      });
      logger.warn(idbGetError.message);
    }
  }
}
function computeKey(app2) {
  return `${app2.name}!${app2.options.appId}`;
}
function getUTCDateString() {
  const today = /* @__PURE__ */ new Date();
  return today.toISOString().substring(0, 10);
}
function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
  const heartbeatsToSend = [];
  let unsentEntries = heartbeatsCache.slice();
  for (const singleDateHeartbeat of heartbeatsCache) {
    const heartbeatEntry = heartbeatsToSend.find((hb) => hb.agent === singleDateHeartbeat.agent);
    if (!heartbeatEntry) {
      heartbeatsToSend.push({
        agent: singleDateHeartbeat.agent,
        dates: [singleDateHeartbeat.date]
      });
      if (countBytes(heartbeatsToSend) > maxSize) {
        heartbeatsToSend.pop();
        break;
      }
    } else {
      heartbeatEntry.dates.push(singleDateHeartbeat.date);
      if (countBytes(heartbeatsToSend) > maxSize) {
        heartbeatEntry.dates.pop();
        break;
      }
    }
    unsentEntries = unsentEntries.slice(1);
  }
  return {
    heartbeatsToSend,
    unsentEntries
  };
}
function countBytes(heartbeatsCache) {
  return base64urlEncodeWithoutPadding(
    // heartbeatsCache wrapper properties
    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })
  ).length;
}
function getEarliestHeartbeatIdx(heartbeats) {
  if (heartbeats.length === 0) {
    return -1;
  }
  let earliestHeartbeatIdx = 0;
  let earliestHeartbeatDate = heartbeats[0].date;
  for (let i = 1; i < heartbeats.length; i++) {
    if (heartbeats[i].date < earliestHeartbeatDate) {
      earliestHeartbeatDate = heartbeats[i].date;
      earliestHeartbeatIdx = i;
    }
  }
  return earliestHeartbeatIdx;
}
function registerCoreComponents(variant) {
  _registerComponent(new Component(
    "platform-logger",
    (container) => new PlatformLoggerServiceImpl(container),
    "PRIVATE"
    /* ComponentType.PRIVATE */
  ));
  _registerComponent(new Component(
    "heartbeat",
    (container) => new HeartbeatServiceImpl(container),
    "PRIVATE"
    /* ComponentType.PRIVATE */
  ));
  registerVersion(name$q, version$1, variant);
  registerVersion(name$q, version$1, "esm2020");
  registerVersion("fire-js", "");
}
var PlatformLoggerServiceImpl, name$q, version$1, logger, name$p, name$o, name$n, name$m, name$l, name$k, name$j, name$i, name$h, name$g, name$f, name$e, name$d, name$c, name$b, name$a, name$9, name$8, name$7, name$6, name$5, name$4, name$3, name$2, name$1, name, version, DEFAULT_ENTRY_NAME2, PLATFORM_LOG_STRING, _apps, _serverApps, _components, ERRORS, ERROR_FACTORY, FirebaseAppImpl, SDK_VERSION, DB_NAME, DB_VERSION, STORE_NAME, dbPromise, MAX_HEADER_BYTES, MAX_NUM_STORED_HEARTBEATS, HeartbeatServiceImpl, HeartbeatStorageImpl;
var init_index_esm3 = __esm({
  "node_modules/@firebase/app/dist/esm/index.esm.js"() {
    init_index_esm();
    init_index_esm2();
    init_index_node_esm();
    init_index_node_esm();
    init_build();
    PlatformLoggerServiceImpl = class {
      constructor(container) {
        this.container = container;
      }
      // In initial implementation, this will be called by installations on
      // auth token refresh, and installations will send this string.
      getPlatformInfoString() {
        const providers = this.container.getProviders();
        return providers.map((provider) => {
          if (isVersionServiceProvider(provider)) {
            const service = provider.getImmediate();
            return `${service.library}/${service.version}`;
          } else {
            return null;
          }
        }).filter((logString) => logString).join(" ");
      }
    };
    name$q = "@firebase/app";
    version$1 = "0.14.5";
    logger = new Logger("@firebase/app");
    name$p = "@firebase/app-compat";
    name$o = "@firebase/analytics-compat";
    name$n = "@firebase/analytics";
    name$m = "@firebase/app-check-compat";
    name$l = "@firebase/app-check";
    name$k = "@firebase/auth";
    name$j = "@firebase/auth-compat";
    name$i = "@firebase/database";
    name$h = "@firebase/data-connect";
    name$g = "@firebase/database-compat";
    name$f = "@firebase/functions";
    name$e = "@firebase/functions-compat";
    name$d = "@firebase/installations";
    name$c = "@firebase/installations-compat";
    name$b = "@firebase/messaging";
    name$a = "@firebase/messaging-compat";
    name$9 = "@firebase/performance";
    name$8 = "@firebase/performance-compat";
    name$7 = "@firebase/remote-config";
    name$6 = "@firebase/remote-config-compat";
    name$5 = "@firebase/storage";
    name$4 = "@firebase/storage-compat";
    name$3 = "@firebase/firestore";
    name$2 = "@firebase/ai";
    name$1 = "@firebase/firestore-compat";
    name = "firebase";
    version = "12.5.0";
    DEFAULT_ENTRY_NAME2 = "[DEFAULT]";
    PLATFORM_LOG_STRING = {
      [name$q]: "fire-core",
      [name$p]: "fire-core-compat",
      [name$n]: "fire-analytics",
      [name$o]: "fire-analytics-compat",
      [name$l]: "fire-app-check",
      [name$m]: "fire-app-check-compat",
      [name$k]: "fire-auth",
      [name$j]: "fire-auth-compat",
      [name$i]: "fire-rtdb",
      [name$h]: "fire-data-connect",
      [name$g]: "fire-rtdb-compat",
      [name$f]: "fire-fn",
      [name$e]: "fire-fn-compat",
      [name$d]: "fire-iid",
      [name$c]: "fire-iid-compat",
      [name$b]: "fire-fcm",
      [name$a]: "fire-fcm-compat",
      [name$9]: "fire-perf",
      [name$8]: "fire-perf-compat",
      [name$7]: "fire-rc",
      [name$6]: "fire-rc-compat",
      [name$5]: "fire-gcs",
      [name$4]: "fire-gcs-compat",
      [name$3]: "fire-fst",
      [name$1]: "fire-fst-compat",
      [name$2]: "fire-vertex",
      "fire-js": "fire-js",
      // Platform identifier for JS SDK.
      [name]: "fire-js-all"
    };
    _apps = /* @__PURE__ */ new Map();
    _serverApps = /* @__PURE__ */ new Map();
    _components = /* @__PURE__ */ new Map();
    ERRORS = {
      [
        "no-app"
        /* AppError.NO_APP */
      ]: "No Firebase App '{$appName}' has been created - call initializeApp() first",
      [
        "bad-app-name"
        /* AppError.BAD_APP_NAME */
      ]: "Illegal App name: '{$appName}'",
      [
        "duplicate-app"
        /* AppError.DUPLICATE_APP */
      ]: "Firebase App named '{$appName}' already exists with different options or config",
      [
        "app-deleted"
        /* AppError.APP_DELETED */
      ]: "Firebase App named '{$appName}' already deleted",
      [
        "server-app-deleted"
        /* AppError.SERVER_APP_DELETED */
      ]: "Firebase Server App has been deleted",
      [
        "no-options"
        /* AppError.NO_OPTIONS */
      ]: "Need to provide options, when not being deployed to hosting via source.",
      [
        "invalid-app-argument"
        /* AppError.INVALID_APP_ARGUMENT */
      ]: "firebase.{$appName}() takes either no argument or a Firebase App instance.",
      [
        "invalid-log-argument"
        /* AppError.INVALID_LOG_ARGUMENT */
      ]: "First argument to `onLog` must be null or a function.",
      [
        "idb-open"
        /* AppError.IDB_OPEN */
      ]: "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "idb-get"
        /* AppError.IDB_GET */
      ]: "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "idb-set"
        /* AppError.IDB_WRITE */
      ]: "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "idb-delete"
        /* AppError.IDB_DELETE */
      ]: "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "finalization-registry-not-supported"
        /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */
      ]: "FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.",
      [
        "invalid-server-app-environment"
        /* AppError.INVALID_SERVER_APP_ENVIRONMENT */
      ]: "FirebaseServerApp is not for use in browser environments."
    };
    ERROR_FACTORY = new ErrorFactory("app", "Firebase", ERRORS);
    FirebaseAppImpl = class {
      constructor(options, config, container) {
        this._isDeleted = false;
        this._options = { ...options };
        this._config = { ...config };
        this._name = config.name;
        this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;
        this._container = container;
        this.container.addComponent(new Component(
          "app",
          () => this,
          "PUBLIC"
          /* ComponentType.PUBLIC */
        ));
      }
      get automaticDataCollectionEnabled() {
        this.checkDestroyed();
        return this._automaticDataCollectionEnabled;
      }
      set automaticDataCollectionEnabled(val) {
        this.checkDestroyed();
        this._automaticDataCollectionEnabled = val;
      }
      get name() {
        this.checkDestroyed();
        return this._name;
      }
      get options() {
        this.checkDestroyed();
        return this._options;
      }
      get config() {
        this.checkDestroyed();
        return this._config;
      }
      get container() {
        return this._container;
      }
      get isDeleted() {
        return this._isDeleted;
      }
      set isDeleted(val) {
        this._isDeleted = val;
      }
      /**
       * This function will throw an Error if the App has already been deleted -
       * use before performing API actions on the App.
       */
      checkDestroyed() {
        if (this.isDeleted) {
          throw ERROR_FACTORY.create("app-deleted", { appName: this._name });
        }
      }
    };
    SDK_VERSION = version;
    DB_NAME = "firebase-heartbeat-database";
    DB_VERSION = 1;
    STORE_NAME = "firebase-heartbeat-store";
    dbPromise = null;
    MAX_HEADER_BYTES = 1024;
    MAX_NUM_STORED_HEARTBEATS = 30;
    HeartbeatServiceImpl = class {
      constructor(container) {
        this.container = container;
        this._heartbeatsCache = null;
        const app2 = this.container.getProvider("app").getImmediate();
        this._storage = new HeartbeatStorageImpl(app2);
        this._heartbeatsCachePromise = this._storage.read().then((result) => {
          this._heartbeatsCache = result;
          return result;
        });
      }
      /**
       * Called to report a heartbeat. The function will generate
       * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
       * to IndexedDB.
       * Note that we only store one heartbeat per day. So if a heartbeat for today is
       * already logged, subsequent calls to this function in the same day will be ignored.
       */
      async triggerHeartbeat() {
        try {
          const platformLogger = this.container.getProvider("platform-logger").getImmediate();
          const agent = platformLogger.getPlatformInfoString();
          const date = getUTCDateString();
          if (this._heartbeatsCache?.heartbeats == null) {
            this._heartbeatsCache = await this._heartbeatsCachePromise;
            if (this._heartbeatsCache?.heartbeats == null) {
              return;
            }
          }
          if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some((singleDateHeartbeat) => singleDateHeartbeat.date === date)) {
            return;
          } else {
            this._heartbeatsCache.heartbeats.push({ date, agent });
            if (this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS) {
              const earliestHeartbeatIdx = getEarliestHeartbeatIdx(this._heartbeatsCache.heartbeats);
              this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);
            }
          }
          return this._storage.overwrite(this._heartbeatsCache);
        } catch (e) {
          logger.warn(e);
        }
      }
      /**
       * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
       * It also clears all heartbeats from memory as well as in IndexedDB.
       *
       * NOTE: Consuming product SDKs should not send the header if this method
       * returns an empty string.
       */
      async getHeartbeatsHeader() {
        try {
          if (this._heartbeatsCache === null) {
            await this._heartbeatsCachePromise;
          }
          if (this._heartbeatsCache?.heartbeats == null || this._heartbeatsCache.heartbeats.length === 0) {
            return "";
          }
          const date = getUTCDateString();
          const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
          const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
          this._heartbeatsCache.lastSentHeartbeatDate = date;
          if (unsentEntries.length > 0) {
            this._heartbeatsCache.heartbeats = unsentEntries;
            await this._storage.overwrite(this._heartbeatsCache);
          } else {
            this._heartbeatsCache.heartbeats = [];
            void this._storage.overwrite(this._heartbeatsCache);
          }
          return headerString;
        } catch (e) {
          logger.warn(e);
          return "";
        }
      }
    };
    HeartbeatStorageImpl = class {
      constructor(app2) {
        this.app = app2;
        this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
      }
      async runIndexedDBEnvironmentCheck() {
        if (!isIndexedDBAvailable()) {
          return false;
        } else {
          return validateIndexedDBOpenable().then(() => true).catch(() => false);
        }
      }
      /**
       * Read all heartbeats.
       */
      async read() {
        const canUseIndexedDB = await this._canUseIndexedDBPromise;
        if (!canUseIndexedDB) {
          return { heartbeats: [] };
        } else {
          const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
          if (idbHeartbeatObject?.heartbeats) {
            return idbHeartbeatObject;
          } else {
            return { heartbeats: [] };
          }
        }
      }
      // overwrite the storage with the provided heartbeats
      async overwrite(heartbeatsObject) {
        const canUseIndexedDB = await this._canUseIndexedDBPromise;
        if (!canUseIndexedDB) {
          return;
        } else {
          const existingHeartbeatsObject = await this.read();
          return writeHeartbeatsToIndexedDB(this.app, {
            lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ?? existingHeartbeatsObject.lastSentHeartbeatDate,
            heartbeats: heartbeatsObject.heartbeats
          });
        }
      }
      // add heartbeats
      async add(heartbeatsObject) {
        const canUseIndexedDB = await this._canUseIndexedDBPromise;
        if (!canUseIndexedDB) {
          return;
        } else {
          const existingHeartbeatsObject = await this.read();
          return writeHeartbeatsToIndexedDB(this.app, {
            lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ?? existingHeartbeatsObject.lastSentHeartbeatDate,
            heartbeats: [
              ...existingHeartbeatsObject.heartbeats,
              ...heartbeatsObject.heartbeats
            ]
          });
        }
      }
    };
    registerCoreComponents("");
  }
});

// node_modules/firebase/app/dist/index.mjs
var name2, version2;
var init_dist = __esm({
  "node_modules/firebase/app/dist/index.mjs"() {
    init_index_esm3();
    init_index_esm3();
    name2 = "firebase";
    version2 = "12.5.0";
    registerVersion(name2, version2, "app");
  }
});

// node_modules/@firebase/auth/dist/node-esm/totp-c8d207b9.js
function _debugErrorMap() {
  return {
    [
      "admin-restricted-operation"
      /* AuthErrorCode.ADMIN_ONLY_OPERATION */
    ]: "This operation is restricted to administrators only.",
    [
      "argument-error"
      /* AuthErrorCode.ARGUMENT_ERROR */
    ]: "",
    [
      "app-not-authorized"
      /* AuthErrorCode.APP_NOT_AUTHORIZED */
    ]: "This app, identified by the domain where it's hosted, is not authorized to use Firebase Authentication with the provided API key. Review your key configuration in the Google API console.",
    [
      "app-not-installed"
      /* AuthErrorCode.APP_NOT_INSTALLED */
    ]: "The requested mobile application corresponding to the identifier (Android package name or iOS bundle ID) provided is not installed on this device.",
    [
      "captcha-check-failed"
      /* AuthErrorCode.CAPTCHA_CHECK_FAILED */
    ]: "The reCAPTCHA response token provided is either invalid, expired, already used or the domain associated with it does not match the list of whitelisted domains.",
    [
      "code-expired"
      /* AuthErrorCode.CODE_EXPIRED */
    ]: "The SMS code has expired. Please re-send the verification code to try again.",
    [
      "cordova-not-ready"
      /* AuthErrorCode.CORDOVA_NOT_READY */
    ]: "Cordova framework is not ready.",
    [
      "cors-unsupported"
      /* AuthErrorCode.CORS_UNSUPPORTED */
    ]: "This browser is not supported.",
    [
      "credential-already-in-use"
      /* AuthErrorCode.CREDENTIAL_ALREADY_IN_USE */
    ]: "This credential is already associated with a different user account.",
    [
      "custom-token-mismatch"
      /* AuthErrorCode.CREDENTIAL_MISMATCH */
    ]: "The custom token corresponds to a different audience.",
    [
      "requires-recent-login"
      /* AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */
    ]: "This operation is sensitive and requires recent authentication. Log in again before retrying this request.",
    [
      "dependent-sdk-initialized-before-auth"
      /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
    ]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK.",
    [
      "dynamic-link-not-activated"
      /* AuthErrorCode.DYNAMIC_LINK_NOT_ACTIVATED */
    ]: "Please activate Dynamic Links in the Firebase Console and agree to the terms and conditions.",
    [
      "email-change-needs-verification"
      /* AuthErrorCode.EMAIL_CHANGE_NEEDS_VERIFICATION */
    ]: "Multi-factor users must always have a verified email.",
    [
      "email-already-in-use"
      /* AuthErrorCode.EMAIL_EXISTS */
    ]: "The email address is already in use by another account.",
    [
      "emulator-config-failed"
      /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
    ]: 'Auth instance has already been used to make a network call. Auth can no longer be configured to use the emulator. Try calling "connectAuthEmulator()" sooner.',
    [
      "expired-action-code"
      /* AuthErrorCode.EXPIRED_OOB_CODE */
    ]: "The action code has expired.",
    [
      "cancelled-popup-request"
      /* AuthErrorCode.EXPIRED_POPUP_REQUEST */
    ]: "This operation has been cancelled due to another conflicting popup being opened.",
    [
      "internal-error"
      /* AuthErrorCode.INTERNAL_ERROR */
    ]: "An internal AuthError has occurred.",
    [
      "invalid-app-credential"
      /* AuthErrorCode.INVALID_APP_CREDENTIAL */
    ]: "The phone verification request contains an invalid application verifier. The reCAPTCHA token response is either invalid or expired.",
    [
      "invalid-app-id"
      /* AuthErrorCode.INVALID_APP_ID */
    ]: "The mobile app identifier is not registered for the current project.",
    [
      "invalid-user-token"
      /* AuthErrorCode.INVALID_AUTH */
    ]: "This user's credential isn't valid for this project. This can happen if the user's token has been tampered with, or if the user isn't for the project associated with this API key.",
    [
      "invalid-auth-event"
      /* AuthErrorCode.INVALID_AUTH_EVENT */
    ]: "An internal AuthError has occurred.",
    [
      "invalid-verification-code"
      /* AuthErrorCode.INVALID_CODE */
    ]: "The SMS verification code used to create the phone auth credential is invalid. Please resend the verification code sms and be sure to use the verification code provided by the user.",
    [
      "invalid-continue-uri"
      /* AuthErrorCode.INVALID_CONTINUE_URI */
    ]: "The continue URL provided in the request is invalid.",
    [
      "invalid-cordova-configuration"
      /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */
    ]: "The following Cordova plugins must be installed to enable OAuth sign-in: cordova-plugin-buildinfo, cordova-universal-links-plugin, cordova-plugin-browsertab, cordova-plugin-inappbrowser and cordova-plugin-customurlscheme.",
    [
      "invalid-custom-token"
      /* AuthErrorCode.INVALID_CUSTOM_TOKEN */
    ]: "The custom token format is incorrect. Please check the documentation.",
    [
      "invalid-dynamic-link-domain"
      /* AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN */
    ]: "The provided dynamic link domain is not configured or authorized for the current project.",
    [
      "invalid-email"
      /* AuthErrorCode.INVALID_EMAIL */
    ]: "The email address is badly formatted.",
    [
      "invalid-emulator-scheme"
      /* AuthErrorCode.INVALID_EMULATOR_SCHEME */
    ]: "Emulator URL must start with a valid scheme (http:// or https://).",
    [
      "invalid-api-key"
      /* AuthErrorCode.INVALID_API_KEY */
    ]: "Your API key is invalid, please check you have copied it correctly.",
    [
      "invalid-cert-hash"
      /* AuthErrorCode.INVALID_CERT_HASH */
    ]: "The SHA-1 certificate hash provided is invalid.",
    [
      "invalid-credential"
      /* AuthErrorCode.INVALID_CREDENTIAL */
    ]: "The supplied auth credential is incorrect, malformed or has expired.",
    [
      "invalid-message-payload"
      /* AuthErrorCode.INVALID_MESSAGE_PAYLOAD */
    ]: "The email template corresponding to this action contains invalid characters in its message. Please fix by going to the Auth email templates section in the Firebase Console.",
    [
      "invalid-multi-factor-session"
      /* AuthErrorCode.INVALID_MFA_SESSION */
    ]: "The request does not contain a valid proof of first factor successful sign-in.",
    [
      "invalid-oauth-provider"
      /* AuthErrorCode.INVALID_OAUTH_PROVIDER */
    ]: "EmailAuthProvider is not supported for this operation. This operation only supports OAuth providers.",
    [
      "invalid-oauth-client-id"
      /* AuthErrorCode.INVALID_OAUTH_CLIENT_ID */
    ]: "The OAuth client ID provided is either invalid or does not match the specified API key.",
    [
      "unauthorized-domain"
      /* AuthErrorCode.INVALID_ORIGIN */
    ]: "This domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.",
    [
      "invalid-action-code"
      /* AuthErrorCode.INVALID_OOB_CODE */
    ]: "The action code is invalid. This can happen if the code is malformed, expired, or has already been used.",
    [
      "wrong-password"
      /* AuthErrorCode.INVALID_PASSWORD */
    ]: "The password is invalid or the user does not have a password.",
    [
      "invalid-persistence-type"
      /* AuthErrorCode.INVALID_PERSISTENCE */
    ]: "The specified persistence type is invalid. It can only be local, session or none.",
    [
      "invalid-phone-number"
      /* AuthErrorCode.INVALID_PHONE_NUMBER */
    ]: "The format of the phone number provided is incorrect. Please enter the phone number in a format that can be parsed into E.164 format. E.164 phone numbers are written in the format [+][country code][subscriber number including area code].",
    [
      "invalid-provider-id"
      /* AuthErrorCode.INVALID_PROVIDER_ID */
    ]: "The specified provider ID is invalid.",
    [
      "invalid-recipient-email"
      /* AuthErrorCode.INVALID_RECIPIENT_EMAIL */
    ]: "The email corresponding to this action failed to send as the provided recipient email address is invalid.",
    [
      "invalid-sender"
      /* AuthErrorCode.INVALID_SENDER */
    ]: "The email template corresponding to this action contains an invalid sender email or name. Please fix by going to the Auth email templates section in the Firebase Console.",
    [
      "invalid-verification-id"
      /* AuthErrorCode.INVALID_SESSION_INFO */
    ]: "The verification ID used to create the phone auth credential is invalid.",
    [
      "invalid-tenant-id"
      /* AuthErrorCode.INVALID_TENANT_ID */
    ]: "The Auth instance's tenant ID is invalid.",
    [
      "login-blocked"
      /* AuthErrorCode.LOGIN_BLOCKED */
    ]: "Login blocked by user-provided method: {$originalMessage}",
    [
      "missing-android-pkg-name"
      /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */
    ]: "An Android Package Name must be provided if the Android App is required to be installed.",
    [
      "auth-domain-config-required"
      /* AuthErrorCode.MISSING_AUTH_DOMAIN */
    ]: "Be sure to include authDomain when calling firebase.initializeApp(), by following the instructions in the Firebase console.",
    [
      "missing-app-credential"
      /* AuthErrorCode.MISSING_APP_CREDENTIAL */
    ]: "The phone verification request is missing an application verifier assertion. A reCAPTCHA response token needs to be provided.",
    [
      "missing-verification-code"
      /* AuthErrorCode.MISSING_CODE */
    ]: "The phone auth credential was created with an empty SMS verification code.",
    [
      "missing-continue-uri"
      /* AuthErrorCode.MISSING_CONTINUE_URI */
    ]: "A continue URL must be provided in the request.",
    [
      "missing-iframe-start"
      /* AuthErrorCode.MISSING_IFRAME_START */
    ]: "An internal AuthError has occurred.",
    [
      "missing-ios-bundle-id"
      /* AuthErrorCode.MISSING_IOS_BUNDLE_ID */
    ]: "An iOS Bundle ID must be provided if an App Store ID is provided.",
    [
      "missing-or-invalid-nonce"
      /* AuthErrorCode.MISSING_OR_INVALID_NONCE */
    ]: "The request does not contain a valid nonce. This can occur if the SHA-256 hash of the provided raw nonce does not match the hashed nonce in the ID token payload.",
    [
      "missing-password"
      /* AuthErrorCode.MISSING_PASSWORD */
    ]: "A non-empty password must be provided",
    [
      "missing-multi-factor-info"
      /* AuthErrorCode.MISSING_MFA_INFO */
    ]: "No second factor identifier is provided.",
    [
      "missing-multi-factor-session"
      /* AuthErrorCode.MISSING_MFA_SESSION */
    ]: "The request is missing proof of first factor successful sign-in.",
    [
      "missing-phone-number"
      /* AuthErrorCode.MISSING_PHONE_NUMBER */
    ]: "To send verification codes, provide a phone number for the recipient.",
    [
      "missing-verification-id"
      /* AuthErrorCode.MISSING_SESSION_INFO */
    ]: "The phone auth credential was created with an empty verification ID.",
    [
      "app-deleted"
      /* AuthErrorCode.MODULE_DESTROYED */
    ]: "This instance of FirebaseApp has been deleted.",
    [
      "multi-factor-info-not-found"
      /* AuthErrorCode.MFA_INFO_NOT_FOUND */
    ]: "The user does not have a second factor matching the identifier provided.",
    [
      "multi-factor-auth-required"
      /* AuthErrorCode.MFA_REQUIRED */
    ]: "Proof of ownership of a second factor is required to complete sign-in.",
    [
      "account-exists-with-different-credential"
      /* AuthErrorCode.NEED_CONFIRMATION */
    ]: "An account already exists with the same email address but different sign-in credentials. Sign in using a provider associated with this email address.",
    [
      "network-request-failed"
      /* AuthErrorCode.NETWORK_REQUEST_FAILED */
    ]: "A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.",
    [
      "no-auth-event"
      /* AuthErrorCode.NO_AUTH_EVENT */
    ]: "An internal AuthError has occurred.",
    [
      "no-such-provider"
      /* AuthErrorCode.NO_SUCH_PROVIDER */
    ]: "User was not linked to an account with the given provider.",
    [
      "null-user"
      /* AuthErrorCode.NULL_USER */
    ]: "A null user object was provided as the argument for an operation which requires a non-null user object.",
    [
      "operation-not-allowed"
      /* AuthErrorCode.OPERATION_NOT_ALLOWED */
    ]: "The given sign-in provider is disabled for this Firebase project. Enable it in the Firebase console, under the sign-in method tab of the Auth section.",
    [
      "operation-not-supported-in-this-environment"
      /* AuthErrorCode.OPERATION_NOT_SUPPORTED */
    ]: 'This operation is not supported in the environment this application is running on. "location.protocol" must be http, https or chrome-extension and web storage must be enabled.',
    [
      "popup-blocked"
      /* AuthErrorCode.POPUP_BLOCKED */
    ]: "Unable to establish a connection with the popup. It may have been blocked by the browser.",
    [
      "popup-closed-by-user"
      /* AuthErrorCode.POPUP_CLOSED_BY_USER */
    ]: "The popup has been closed by the user before finalizing the operation.",
    [
      "provider-already-linked"
      /* AuthErrorCode.PROVIDER_ALREADY_LINKED */
    ]: "User can only be linked to one identity for the given provider.",
    [
      "quota-exceeded"
      /* AuthErrorCode.QUOTA_EXCEEDED */
    ]: "The project's quota for this operation has been exceeded.",
    [
      "redirect-cancelled-by-user"
      /* AuthErrorCode.REDIRECT_CANCELLED_BY_USER */
    ]: "The redirect operation has been cancelled by the user before finalizing.",
    [
      "redirect-operation-pending"
      /* AuthErrorCode.REDIRECT_OPERATION_PENDING */
    ]: "A redirect sign-in operation is already pending.",
    [
      "rejected-credential"
      /* AuthErrorCode.REJECTED_CREDENTIAL */
    ]: "The request contains malformed or mismatching credentials.",
    [
      "second-factor-already-in-use"
      /* AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED */
    ]: "The second factor is already enrolled on this account.",
    [
      "maximum-second-factor-count-exceeded"
      /* AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED */
    ]: "The maximum allowed number of second factors on a user has been exceeded.",
    [
      "tenant-id-mismatch"
      /* AuthErrorCode.TENANT_ID_MISMATCH */
    ]: "The provided tenant ID does not match the Auth instance's tenant ID",
    [
      "timeout"
      /* AuthErrorCode.TIMEOUT */
    ]: "The operation has timed out.",
    [
      "user-token-expired"
      /* AuthErrorCode.TOKEN_EXPIRED */
    ]: "The user's credential is no longer valid. The user must sign in again.",
    [
      "too-many-requests"
      /* AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER */
    ]: "We have blocked all requests from this device due to unusual activity. Try again later.",
    [
      "unauthorized-continue-uri"
      /* AuthErrorCode.UNAUTHORIZED_DOMAIN */
    ]: "The domain of the continue URL is not whitelisted.  Please whitelist the domain in the Firebase console.",
    [
      "unsupported-first-factor"
      /* AuthErrorCode.UNSUPPORTED_FIRST_FACTOR */
    ]: "Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.",
    [
      "unsupported-persistence-type"
      /* AuthErrorCode.UNSUPPORTED_PERSISTENCE */
    ]: "The current environment does not support the specified persistence type.",
    [
      "unsupported-tenant-operation"
      /* AuthErrorCode.UNSUPPORTED_TENANT_OPERATION */
    ]: "This operation is not supported in a multi-tenant context.",
    [
      "unverified-email"
      /* AuthErrorCode.UNVERIFIED_EMAIL */
    ]: "The operation requires a verified email.",
    [
      "user-cancelled"
      /* AuthErrorCode.USER_CANCELLED */
    ]: "The user did not grant your application the permissions it requested.",
    [
      "user-not-found"
      /* AuthErrorCode.USER_DELETED */
    ]: "There is no user record corresponding to this identifier. The user may have been deleted.",
    [
      "user-disabled"
      /* AuthErrorCode.USER_DISABLED */
    ]: "The user account has been disabled by an administrator.",
    [
      "user-mismatch"
      /* AuthErrorCode.USER_MISMATCH */
    ]: "The supplied credentials do not correspond to the previously signed in user.",
    [
      "user-signed-out"
      /* AuthErrorCode.USER_SIGNED_OUT */
    ]: "",
    [
      "weak-password"
      /* AuthErrorCode.WEAK_PASSWORD */
    ]: "The password must be 6 characters long or more.",
    [
      "web-storage-unsupported"
      /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */
    ]: "This browser is not supported or 3rd party cookies and data may be disabled.",
    [
      "already-initialized"
      /* AuthErrorCode.ALREADY_INITIALIZED */
    ]: "initializeAuth() has already been called with different options. To avoid this error, call initializeAuth() with the same options as when it was originally called, or call getAuth() to return the already initialized instance.",
    [
      "missing-recaptcha-token"
      /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */
    ]: "The reCAPTCHA token is missing when sending request to the backend.",
    [
      "invalid-recaptcha-token"
      /* AuthErrorCode.INVALID_RECAPTCHA_TOKEN */
    ]: "The reCAPTCHA token is invalid when sending request to the backend.",
    [
      "invalid-recaptcha-action"
      /* AuthErrorCode.INVALID_RECAPTCHA_ACTION */
    ]: "The reCAPTCHA action is invalid when sending request to the backend.",
    [
      "recaptcha-not-enabled"
      /* AuthErrorCode.RECAPTCHA_NOT_ENABLED */
    ]: "reCAPTCHA Enterprise integration is not enabled for this project.",
    [
      "missing-client-type"
      /* AuthErrorCode.MISSING_CLIENT_TYPE */
    ]: "The reCAPTCHA client type is missing when sending request to the backend.",
    [
      "missing-recaptcha-version"
      /* AuthErrorCode.MISSING_RECAPTCHA_VERSION */
    ]: "The reCAPTCHA version is missing when sending request to the backend.",
    [
      "invalid-req-type"
      /* AuthErrorCode.INVALID_REQ_TYPE */
    ]: "Invalid request parameters.",
    [
      "invalid-recaptcha-version"
      /* AuthErrorCode.INVALID_RECAPTCHA_VERSION */
    ]: "The reCAPTCHA version is invalid when sending request to the backend.",
    [
      "unsupported-password-policy-schema-version"
      /* AuthErrorCode.UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION */
    ]: "The password policy received from the backend uses a schema version that is not supported by this version of the Firebase SDK.",
    [
      "password-does-not-meet-requirements"
      /* AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS */
    ]: "The password does not meet the requirements.",
    [
      "invalid-hosting-link-domain"
      /* AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN */
    ]: "The provided Hosting link domain is not configured in Firebase Hosting or is not owned by the current project. This cannot be a default Hosting domain (`web.app` or `firebaseapp.com`)."
  };
}
function _prodErrorMap() {
  return {
    [
      "dependent-sdk-initialized-before-auth"
      /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
    ]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK."
  };
}
function _logWarn(msg, ...args) {
  if (logClient.logLevel <= LogLevel.WARN) {
    logClient.warn(`Auth (${SDK_VERSION}): ${msg}`, ...args);
  }
}
function _logError(msg, ...args) {
  if (logClient.logLevel <= LogLevel.ERROR) {
    logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);
  }
}
function _fail(authOrCode, ...rest) {
  throw createErrorInternal(authOrCode, ...rest);
}
function _createError(authOrCode, ...rest) {
  return createErrorInternal(authOrCode, ...rest);
}
function _errorWithCustomMessage(auth2, code, message) {
  const errorMap = {
    ...prodErrorMap(),
    [code]: message
  };
  const factory2 = new ErrorFactory("auth", "Firebase", errorMap);
  return factory2.create(code, {
    appName: auth2.name
  });
}
function _serverAppCurrentUserOperationNotSupportedError(auth2) {
  return _errorWithCustomMessage(auth2, "operation-not-supported-in-this-environment", "Operations that alter the current user are not supported in conjunction with FirebaseServerApp");
}
function createErrorInternal(authOrCode, ...rest) {
  if (typeof authOrCode !== "string") {
    const code = rest[0];
    const fullParams = [...rest.slice(1)];
    if (fullParams[0]) {
      fullParams[0].appName = authOrCode.name;
    }
    return authOrCode._errorFactory.create(code, ...fullParams);
  }
  return _DEFAULT_AUTH_ERROR_FACTORY.create(authOrCode, ...rest);
}
function _assert(assertion, authOrCode, ...rest) {
  if (!assertion) {
    throw createErrorInternal(authOrCode, ...rest);
  }
}
function debugFail(failure) {
  const message = `INTERNAL ASSERTION FAILED: ` + failure;
  _logError(message);
  throw new Error(message);
}
function debugAssert(assertion, message) {
  if (!assertion) {
    debugFail(message);
  }
}
function _getCurrentUrl() {
  return typeof self !== "undefined" && self.location?.href || "";
}
function _isHttpOrHttps() {
  return _getCurrentScheme() === "http:" || _getCurrentScheme() === "https:";
}
function _getCurrentScheme() {
  return typeof self !== "undefined" && self.location?.protocol || null;
}
function _isOnline() {
  if (typeof navigator !== "undefined" && navigator && "onLine" in navigator && typeof navigator.onLine === "boolean" && // Apply only for traditional web apps and Chrome extensions.
  // This is especially true for Cordova apps which have unreliable
  // navigator.onLine behavior unless cordova-plugin-network-information is
  // installed which overwrites the native navigator.onLine value and
  // defines navigator.connection.
  (_isHttpOrHttps() || isBrowserExtension() || "connection" in navigator)) {
    return navigator.onLine;
  }
  return true;
}
function _getUserLanguage() {
  if (typeof navigator === "undefined") {
    return null;
  }
  const navigatorLanguage = navigator;
  return (
    // Most reliable, but only supported in Chrome/Firefox.
    navigatorLanguage.languages && navigatorLanguage.languages[0] || // Supported in most browsers, but returns the language of the browser
    // UI, not the language set in browser settings.
    navigatorLanguage.language || // Couldn't determine language.
    null
  );
}
function _emulatorUrl(config, path) {
  debugAssert(config.emulator, "Emulator should always be set here");
  const { url } = config.emulator;
  if (!path) {
    return url;
  }
  return `${url}${path.startsWith("/") ? path.slice(1) : path}`;
}
function _addTidIfNecessary(auth2, request) {
  if (auth2.tenantId && !request.tenantId) {
    return {
      ...request,
      tenantId: auth2.tenantId
    };
  }
  return request;
}
async function _performApiRequest(auth2, method, path, request, customErrorMap = {}) {
  return _performFetchWithErrorHandling(auth2, customErrorMap, async () => {
    let body = {};
    let params = {};
    if (request) {
      if (method === "GET") {
        params = request;
      } else {
        body = {
          body: JSON.stringify(request)
        };
      }
    }
    const query = querystring({
      key: auth2.config.apiKey,
      ...params
    }).slice(1);
    const headers = await auth2._getAdditionalHeaders();
    headers[
      "Content-Type"
      /* HttpHeader.CONTENT_TYPE */
    ] = "application/json";
    if (auth2.languageCode) {
      headers[
        "X-Firebase-Locale"
        /* HttpHeader.X_FIREBASE_LOCALE */
      ] = auth2.languageCode;
    }
    const fetchArgs = {
      method,
      headers,
      ...body
    };
    if (!isCloudflareWorker()) {
      fetchArgs.referrerPolicy = "no-referrer";
    }
    if (auth2.emulatorConfig && isCloudWorkstation(auth2.emulatorConfig.host)) {
      fetchArgs.credentials = "include";
    }
    return FetchProvider.fetch()(await _getFinalTarget(auth2, auth2.config.apiHost, path, query), fetchArgs);
  });
}
async function _performFetchWithErrorHandling(auth2, customErrorMap, fetchFn) {
  auth2._canInitEmulator = false;
  const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };
  try {
    const networkTimeout = new NetworkTimeout(auth2);
    const response = await Promise.race([
      fetchFn(),
      networkTimeout.promise
    ]);
    networkTimeout.clearNetworkTimeout();
    const json = await response.json();
    if ("needConfirmation" in json) {
      throw _makeTaggedError(auth2, "account-exists-with-different-credential", json);
    }
    if (response.ok && !("errorMessage" in json)) {
      return json;
    } else {
      const errorMessage = response.ok ? json.errorMessage : json.error.message;
      const [serverErrorCode, serverErrorMessage] = errorMessage.split(" : ");
      if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED") {
        throw _makeTaggedError(auth2, "credential-already-in-use", json);
      } else if (serverErrorCode === "EMAIL_EXISTS") {
        throw _makeTaggedError(auth2, "email-already-in-use", json);
      } else if (serverErrorCode === "USER_DISABLED") {
        throw _makeTaggedError(auth2, "user-disabled", json);
      }
      const authError = errorMap[serverErrorCode] || serverErrorCode.toLowerCase().replace(/[_\s]+/g, "-");
      if (serverErrorMessage) {
        throw _errorWithCustomMessage(auth2, authError, serverErrorMessage);
      } else {
        _fail(auth2, authError);
      }
    }
  } catch (e) {
    if (e instanceof FirebaseError) {
      throw e;
    }
    _fail(auth2, "network-request-failed", { "message": String(e) });
  }
}
async function _performSignInRequest(auth2, method, path, request, customErrorMap = {}) {
  const serverResponse = await _performApiRequest(auth2, method, path, request, customErrorMap);
  if ("mfaPendingCredential" in serverResponse) {
    _fail(auth2, "multi-factor-auth-required", {
      _serverResponse: serverResponse
    });
  }
  return serverResponse;
}
async function _getFinalTarget(auth2, host, path, query) {
  const base = `${host}${path}?${query}`;
  const authInternal = auth2;
  const finalTarget = authInternal.config.emulator ? _emulatorUrl(auth2.config, base) : `${auth2.config.apiScheme}://${base}`;
  if (CookieAuthProxiedEndpoints.includes(path)) {
    await authInternal._persistenceManagerAvailable;
    if (authInternal._getPersistenceType() === "COOKIE") {
      const cookiePersistence = authInternal._getPersistence();
      return cookiePersistence._getFinalTarget(finalTarget).toString();
    }
  }
  return finalTarget;
}
function _parseEnforcementState(enforcementStateStr) {
  switch (enforcementStateStr) {
    case "ENFORCE":
      return "ENFORCE";
    case "AUDIT":
      return "AUDIT";
    case "OFF":
      return "OFF";
    default:
      return "ENFORCEMENT_STATE_UNSPECIFIED";
  }
}
function _makeTaggedError(auth2, code, response) {
  const errorParams = {
    appName: auth2.name
  };
  if (response.email) {
    errorParams.email = response.email;
  }
  if (response.phoneNumber) {
    errorParams.phoneNumber = response.phoneNumber;
  }
  const error = _createError(auth2, code, errorParams);
  error.customData._tokenResponse = response;
  return error;
}
function isEnterprise(grecaptcha) {
  return grecaptcha !== void 0 && grecaptcha.enterprise !== void 0;
}
async function getRecaptchaConfig(auth2, request) {
  return _performApiRequest(auth2, "GET", "/v2/recaptchaConfig", _addTidIfNecessary(auth2, request));
}
async function deleteAccount(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:delete", request);
}
async function deleteLinkedAccounts(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:update", request);
}
async function getAccountInfo(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:lookup", request);
}
function utcTimestampToDateString(utcTimestamp) {
  if (!utcTimestamp) {
    return void 0;
  }
  try {
    const date = new Date(Number(utcTimestamp));
    if (!isNaN(date.getTime())) {
      return date.toUTCString();
    }
  } catch (e) {
  }
  return void 0;
}
function getIdToken(user, forceRefresh = false) {
  return getModularInstance(user).getIdToken(forceRefresh);
}
async function getIdTokenResult(user, forceRefresh = false) {
  const userInternal = getModularInstance(user);
  const token = await userInternal.getIdToken(forceRefresh);
  const claims = _parseToken(token);
  _assert(
    claims && claims.exp && claims.auth_time && claims.iat,
    userInternal.auth,
    "internal-error"
    /* AuthErrorCode.INTERNAL_ERROR */
  );
  const firebase = typeof claims.firebase === "object" ? claims.firebase : void 0;
  const signInProvider = firebase?.["sign_in_provider"];
  return {
    claims,
    token,
    authTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.auth_time)),
    issuedAtTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.iat)),
    expirationTime: utcTimestampToDateString(secondsStringToMilliseconds(claims.exp)),
    signInProvider: signInProvider || null,
    signInSecondFactor: firebase?.["sign_in_second_factor"] || null
  };
}
function secondsStringToMilliseconds(seconds) {
  return Number(seconds) * 1e3;
}
function _parseToken(token) {
  const [algorithm, payload, signature] = token.split(".");
  if (algorithm === void 0 || payload === void 0 || signature === void 0) {
    _logError("JWT malformed, contained fewer than 3 sections");
    return null;
  }
  try {
    const decoded = base64Decode(payload);
    if (!decoded) {
      _logError("Failed to decode base64 JWT payload");
      return null;
    }
    return JSON.parse(decoded);
  } catch (e) {
    _logError("Caught error parsing JWT payload as JSON", e?.toString());
    return null;
  }
}
function _tokenExpiresIn(token) {
  const parsedToken = _parseToken(token);
  _assert(
    parsedToken,
    "internal-error"
    /* AuthErrorCode.INTERNAL_ERROR */
  );
  _assert(
    typeof parsedToken.exp !== "undefined",
    "internal-error"
    /* AuthErrorCode.INTERNAL_ERROR */
  );
  _assert(
    typeof parsedToken.iat !== "undefined",
    "internal-error"
    /* AuthErrorCode.INTERNAL_ERROR */
  );
  return Number(parsedToken.exp) - Number(parsedToken.iat);
}
async function _logoutIfInvalidated(user, promise, bypassAuthState = false) {
  if (bypassAuthState) {
    return promise;
  }
  try {
    return await promise;
  } catch (e) {
    if (e instanceof FirebaseError && isUserInvalidated(e)) {
      if (user.auth.currentUser === user) {
        await user.auth.signOut();
      }
    }
    throw e;
  }
}
function isUserInvalidated({ code }) {
  return code === `auth/${"user-disabled"}` || code === `auth/${"user-token-expired"}`;
}
async function _reloadWithoutSaving(user) {
  const auth2 = user.auth;
  const idToken = await user.getIdToken();
  const response = await _logoutIfInvalidated(user, getAccountInfo(auth2, { idToken }));
  _assert(
    response?.users.length,
    auth2,
    "internal-error"
    /* AuthErrorCode.INTERNAL_ERROR */
  );
  const coreAccount = response.users[0];
  user._notifyReloadListener(coreAccount);
  const newProviderData = coreAccount.providerUserInfo?.length ? extractProviderData(coreAccount.providerUserInfo) : [];
  const providerData = mergeProviderData(user.providerData, newProviderData);
  const oldIsAnonymous = user.isAnonymous;
  const newIsAnonymous = !(user.email && coreAccount.passwordHash) && !providerData?.length;
  const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;
  const updates = {
    uid: coreAccount.localId,
    displayName: coreAccount.displayName || null,
    photoURL: coreAccount.photoUrl || null,
    email: coreAccount.email || null,
    emailVerified: coreAccount.emailVerified || false,
    phoneNumber: coreAccount.phoneNumber || null,
    tenantId: coreAccount.tenantId || null,
    providerData,
    metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),
    isAnonymous
  };
  Object.assign(user, updates);
}
async function reload(user) {
  const userInternal = getModularInstance(user);
  await _reloadWithoutSaving(userInternal);
  await userInternal.auth._persistUserIfCurrent(userInternal);
  userInternal.auth._notifyListenersIfCurrent(userInternal);
}
function mergeProviderData(original, newData) {
  const deduped = original.filter((o) => !newData.some((n) => n.providerId === o.providerId));
  return [...deduped, ...newData];
}
function extractProviderData(providers) {
  return providers.map(({ providerId, ...provider }) => {
    return {
      providerId,
      uid: provider.rawId || "",
      displayName: provider.displayName || null,
      email: provider.email || null,
      phoneNumber: provider.phoneNumber || null,
      photoURL: provider.photoUrl || null
    };
  });
}
async function requestStsToken(auth2, refreshToken) {
  const response = await _performFetchWithErrorHandling(auth2, {}, async () => {
    const body = querystring({
      "grant_type": "refresh_token",
      "refresh_token": refreshToken
    }).slice(1);
    const { tokenApiHost, apiKey } = auth2.config;
    const url = await _getFinalTarget(auth2, tokenApiHost, "/v1/token", `key=${apiKey}`);
    const headers = await auth2._getAdditionalHeaders();
    headers[
      "Content-Type"
      /* HttpHeader.CONTENT_TYPE */
    ] = "application/x-www-form-urlencoded";
    const options = {
      method: "POST",
      headers,
      body
    };
    if (auth2.emulatorConfig && isCloudWorkstation(auth2.emulatorConfig.host)) {
      options.credentials = "include";
    }
    return FetchProvider.fetch()(url, options);
  });
  return {
    accessToken: response.access_token,
    expiresIn: response.expires_in,
    refreshToken: response.refresh_token
  };
}
async function revokeToken(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v2/accounts:revokeToken", _addTidIfNecessary(auth2, request));
}
function assertStringOrUndefined(assertion, appName) {
  _assert(typeof assertion === "string" || typeof assertion === "undefined", "internal-error", { appName });
}
function _getInstance(cls) {
  debugAssert(cls instanceof Function, "Expected a class definition");
  let instance = instanceCache.get(cls);
  if (instance) {
    debugAssert(instance instanceof cls, "Instance stored in cache mismatched with class");
    return instance;
  }
  instance = new cls();
  instanceCache.set(cls, instance);
  return instance;
}
function _persistenceKeyName(key, apiKey, appName) {
  return `${"firebase"}:${key}:${apiKey}:${appName}`;
}
function _getBrowserName(userAgent) {
  const ua = userAgent.toLowerCase();
  if (ua.includes("opera/") || ua.includes("opr/") || ua.includes("opios/")) {
    return "Opera";
  } else if (_isIEMobile(ua)) {
    return "IEMobile";
  } else if (ua.includes("msie") || ua.includes("trident/")) {
    return "IE";
  } else if (ua.includes("edge/")) {
    return "Edge";
  } else if (_isFirefox(ua)) {
    return "Firefox";
  } else if (ua.includes("silk/")) {
    return "Silk";
  } else if (_isBlackBerry(ua)) {
    return "Blackberry";
  } else if (_isWebOS(ua)) {
    return "Webos";
  } else if (_isSafari(ua)) {
    return "Safari";
  } else if ((ua.includes("chrome/") || _isChromeIOS(ua)) && !ua.includes("edge/")) {
    return "Chrome";
  } else if (_isAndroid(ua)) {
    return "Android";
  } else {
    const re = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/;
    const matches = userAgent.match(re);
    if (matches?.length === 2) {
      return matches[1];
    }
  }
  return "Other";
}
function _isFirefox(ua = getUA()) {
  return /firefox\//i.test(ua);
}
function _isSafari(userAgent = getUA()) {
  const ua = userAgent.toLowerCase();
  return ua.includes("safari/") && !ua.includes("chrome/") && !ua.includes("crios/") && !ua.includes("android");
}
function _isChromeIOS(ua = getUA()) {
  return /crios\//i.test(ua);
}
function _isIEMobile(ua = getUA()) {
  return /iemobile/i.test(ua);
}
function _isAndroid(ua = getUA()) {
  return /android/i.test(ua);
}
function _isBlackBerry(ua = getUA()) {
  return /blackberry/i.test(ua);
}
function _isWebOS(ua = getUA()) {
  return /webos/i.test(ua);
}
function _getClientVersion(clientPlatform, frameworks = []) {
  let reportedPlatform;
  switch (clientPlatform) {
    case "Browser":
      reportedPlatform = _getBrowserName(getUA());
      break;
    case "Worker":
      reportedPlatform = `${_getBrowserName(getUA())}-${clientPlatform}`;
      break;
    default:
      reportedPlatform = clientPlatform;
  }
  const reportedFrameworks = frameworks.length ? frameworks.join(",") : "FirebaseCore-web";
  return `${reportedPlatform}/${"JsCore"}/${SDK_VERSION}/${reportedFrameworks}`;
}
async function _getPasswordPolicy(auth2, request = {}) {
  return _performApiRequest(auth2, "GET", "/v2/passwordPolicy", _addTidIfNecessary(auth2, request));
}
function _castAuth(auth2) {
  return getModularInstance(auth2);
}
function _loadJS(url) {
  return externalJSProvider.loadJS(url);
}
function _recaptchaEnterpriseScriptUrl() {
  return externalJSProvider.recaptchaEnterpriseScript;
}
async function injectRecaptchaFields(auth2, request, action, isCaptchaResp = false, isFakeToken = false) {
  const verifier = new RecaptchaEnterpriseVerifier(auth2);
  let captchaResponse;
  if (isFakeToken) {
    captchaResponse = FAKE_TOKEN;
  } else {
    try {
      captchaResponse = await verifier.verify(action);
    } catch (error) {
      captchaResponse = await verifier.verify(action, true);
    }
  }
  const newRequest = { ...request };
  if (action === "mfaSmsEnrollment" || action === "mfaSmsSignIn") {
    if ("phoneEnrollmentInfo" in newRequest) {
      const phoneNumber = newRequest.phoneEnrollmentInfo.phoneNumber;
      const recaptchaToken = newRequest.phoneEnrollmentInfo.recaptchaToken;
      Object.assign(newRequest, {
        "phoneEnrollmentInfo": {
          phoneNumber,
          recaptchaToken,
          captchaResponse,
          "clientType": "CLIENT_TYPE_WEB",
          "recaptchaVersion": "RECAPTCHA_ENTERPRISE"
          /* RecaptchaVersion.ENTERPRISE */
        }
      });
    } else if ("phoneSignInInfo" in newRequest) {
      const recaptchaToken = newRequest.phoneSignInInfo.recaptchaToken;
      Object.assign(newRequest, {
        "phoneSignInInfo": {
          recaptchaToken,
          captchaResponse,
          "clientType": "CLIENT_TYPE_WEB",
          "recaptchaVersion": "RECAPTCHA_ENTERPRISE"
          /* RecaptchaVersion.ENTERPRISE */
        }
      });
    }
    return newRequest;
  }
  if (!isCaptchaResp) {
    Object.assign(newRequest, { captchaResponse });
  } else {
    Object.assign(newRequest, { "captchaResp": captchaResponse });
  }
  Object.assign(newRequest, {
    "clientType": "CLIENT_TYPE_WEB"
    /* RecaptchaClientType.WEB */
  });
  Object.assign(newRequest, {
    "recaptchaVersion": "RECAPTCHA_ENTERPRISE"
    /* RecaptchaVersion.ENTERPRISE */
  });
  return newRequest;
}
async function handleRecaptchaFlow(authInstance, request, actionName, actionMethod, recaptchaAuthProvider) {
  if (recaptchaAuthProvider === "EMAIL_PASSWORD_PROVIDER") {
    if (authInstance._getRecaptchaConfig()?.isProviderEnabled(
      "EMAIL_PASSWORD_PROVIDER"
      /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
    )) {
      const requestWithRecaptcha = await injectRecaptchaFields(
        authInstance,
        request,
        actionName,
        actionName === "getOobCode"
        /* RecaptchaActionName.GET_OOB_CODE */
      );
      return actionMethod(authInstance, requestWithRecaptcha);
    } else {
      return actionMethod(authInstance, request).catch(async (error) => {
        if (error.code === `auth/${"missing-recaptcha-token"}`) {
          console.log(`${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`);
          const requestWithRecaptcha = await injectRecaptchaFields(
            authInstance,
            request,
            actionName,
            actionName === "getOobCode"
            /* RecaptchaActionName.GET_OOB_CODE */
          );
          return actionMethod(authInstance, requestWithRecaptcha);
        } else {
          return Promise.reject(error);
        }
      });
    }
  } else if (recaptchaAuthProvider === "PHONE_PROVIDER") {
    if (authInstance._getRecaptchaConfig()?.isProviderEnabled(
      "PHONE_PROVIDER"
      /* RecaptchaAuthProvider.PHONE_PROVIDER */
    )) {
      const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName);
      return actionMethod(authInstance, requestWithRecaptcha).catch(async (error) => {
        if (authInstance._getRecaptchaConfig()?.getProviderEnforcementState(
          "PHONE_PROVIDER"
          /* RecaptchaAuthProvider.PHONE_PROVIDER */
        ) === "AUDIT") {
          if (error.code === `auth/${"missing-recaptcha-token"}` || error.code === `auth/${"invalid-app-credential"}`) {
            console.log(`Failed to verify with reCAPTCHA Enterprise. Automatically triggering the reCAPTCHA v2 flow to complete the ${actionName} flow.`);
            const requestWithRecaptchaFields = await injectRecaptchaFields(
              authInstance,
              request,
              actionName,
              false,
              // isCaptchaResp
              true
              // isFakeToken
            );
            return actionMethod(authInstance, requestWithRecaptchaFields);
          }
        }
        return Promise.reject(error);
      });
    } else {
      const requestWithRecaptchaFields = await injectRecaptchaFields(
        authInstance,
        request,
        actionName,
        false,
        // isCaptchaResp
        true
        // isFakeToken
      );
      return actionMethod(authInstance, requestWithRecaptchaFields);
    }
  } else {
    return Promise.reject(recaptchaAuthProvider + " provider is not supported.");
  }
}
async function _initializeRecaptchaConfig(auth2) {
  const authInternal = _castAuth(auth2);
  const response = await getRecaptchaConfig(authInternal, {
    clientType: "CLIENT_TYPE_WEB",
    version: "RECAPTCHA_ENTERPRISE"
    /* RecaptchaVersion.ENTERPRISE */
  });
  const config = new RecaptchaConfig(response);
  if (authInternal.tenantId == null) {
    authInternal._agentRecaptchaConfig = config;
  } else {
    authInternal._tenantRecaptchaConfigs[authInternal.tenantId] = config;
  }
  if (config.isAnyProviderEnabled()) {
    const verifier = new RecaptchaEnterpriseVerifier(authInternal);
    void verifier.verify();
  }
}
function initializeAuth(app2, deps) {
  const provider = _getProvider(app2, "auth");
  if (provider.isInitialized()) {
    const auth3 = provider.getImmediate();
    const initialOptions = provider.getOptions();
    if (deepEqual(initialOptions, deps ?? {})) {
      return auth3;
    } else {
      _fail(
        auth3,
        "already-initialized"
        /* AuthErrorCode.ALREADY_INITIALIZED */
      );
    }
  }
  const auth2 = provider.initialize({ options: deps });
  return auth2;
}
function _initializeAuthInstance(auth2, deps) {
  const persistence = deps?.persistence || [];
  const hierarchy = (Array.isArray(persistence) ? persistence : [persistence]).map(_getInstance);
  if (deps?.errorMap) {
    auth2._updateErrorMap(deps.errorMap);
  }
  auth2._initializeWithPersistence(hierarchy, deps?.popupRedirectResolver);
}
function connectAuthEmulator(auth2, url, options) {
  const authInternal = _castAuth(auth2);
  _assert(
    /^https?:\/\//.test(url),
    authInternal,
    "invalid-emulator-scheme"
    /* AuthErrorCode.INVALID_EMULATOR_SCHEME */
  );
  const disableWarnings = !!options?.disableWarnings;
  const protocol = extractProtocol(url);
  const { host, port } = extractHostAndPort(url);
  const portStr = port === null ? "" : `:${port}`;
  const emulator = { url: `${protocol}//${host}${portStr}/` };
  const emulatorConfig = Object.freeze({
    host,
    port,
    protocol: protocol.replace(":", ""),
    options: Object.freeze({ disableWarnings })
  });
  if (!authInternal._canInitEmulator) {
    _assert(
      authInternal.config.emulator && authInternal.emulatorConfig,
      authInternal,
      "emulator-config-failed"
      /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
    );
    _assert(
      deepEqual(emulator, authInternal.config.emulator) && deepEqual(emulatorConfig, authInternal.emulatorConfig),
      authInternal,
      "emulator-config-failed"
      /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
    );
    return;
  }
  authInternal.config.emulator = emulator;
  authInternal.emulatorConfig = emulatorConfig;
  authInternal.settings.appVerificationDisabledForTesting = true;
  if (isCloudWorkstation(host)) {
    void pingServer(`${protocol}//${host}${portStr}`);
    updateEmulatorBanner("Auth", true);
  } else if (!disableWarnings) {
    emitEmulatorWarning();
  }
}
function extractProtocol(url) {
  const protocolEnd = url.indexOf(":");
  return protocolEnd < 0 ? "" : url.substr(0, protocolEnd + 1);
}
function extractHostAndPort(url) {
  const protocol = extractProtocol(url);
  const authority = /(\/\/)?([^?#/]+)/.exec(url.substr(protocol.length));
  if (!authority) {
    return { host: "", port: null };
  }
  const hostAndPort = authority[2].split("@").pop() || "";
  const bracketedIPv6 = /^(\[[^\]]+\])(:|$)/.exec(hostAndPort);
  if (bracketedIPv6) {
    const host = bracketedIPv6[1];
    return { host, port: parsePort(hostAndPort.substr(host.length + 1)) };
  } else {
    const [host, port] = hostAndPort.split(":");
    return { host, port: parsePort(port) };
  }
}
function parsePort(portStr) {
  if (!portStr) {
    return null;
  }
  const port = Number(portStr);
  if (isNaN(port)) {
    return null;
  }
  return port;
}
function emitEmulatorWarning() {
  function attachBanner() {
    const el = document.createElement("p");
    const sty = el.style;
    el.innerText = "Running in emulator mode. Do not use with production credentials.";
    sty.position = "fixed";
    sty.width = "100%";
    sty.backgroundColor = "#ffffff";
    sty.border = ".1em solid #000000";
    sty.color = "#b50000";
    sty.bottom = "0px";
    sty.left = "0px";
    sty.margin = "0px";
    sty.zIndex = "10000";
    sty.textAlign = "center";
    el.classList.add("firebase-emulator-warning");
    document.body.appendChild(el);
  }
  if (typeof console !== "undefined" && typeof console.info === "function") {
    console.info("WARNING: You are using the Auth Emulator, which is intended for local testing only.  Do not use with production credentials.");
  }
  if (typeof window !== "undefined" && typeof document !== "undefined") {
    if (document.readyState === "loading") {
      window.addEventListener("DOMContentLoaded", attachBanner);
    } else {
      attachBanner();
    }
  }
}
async function resetPassword(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:resetPassword", _addTidIfNecessary(auth2, request));
}
async function updateEmailPassword(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:update", request);
}
async function linkEmailPassword(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:signUp", request);
}
async function applyActionCode$1(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:update", _addTidIfNecessary(auth2, request));
}
async function signInWithPassword(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithPassword", _addTidIfNecessary(auth2, request));
}
async function sendOobCode(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:sendOobCode", _addTidIfNecessary(auth2, request));
}
async function sendEmailVerification$1(auth2, request) {
  return sendOobCode(auth2, request);
}
async function sendPasswordResetEmail$1(auth2, request) {
  return sendOobCode(auth2, request);
}
async function sendSignInLinkToEmail$1(auth2, request) {
  return sendOobCode(auth2, request);
}
async function verifyAndChangeEmail(auth2, request) {
  return sendOobCode(auth2, request);
}
async function signInWithEmailLink$1(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary(auth2, request));
}
async function signInWithEmailLinkForLinking(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary(auth2, request));
}
async function signInWithIdp(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithIdp", _addTidIfNecessary(auth2, request));
}
async function signInWithPhoneNumber$1(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithPhoneNumber", _addTidIfNecessary(auth2, request));
}
async function linkWithPhoneNumber$1(auth2, request) {
  const response = await _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithPhoneNumber", _addTidIfNecessary(auth2, request));
  if (response.temporaryProof) {
    throw _makeTaggedError(auth2, "account-exists-with-different-credential", response);
  }
  return response;
}
async function verifyPhoneNumberForExisting(auth2, request) {
  const apiRequest = {
    ...request,
    operation: "REAUTH"
  };
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithPhoneNumber", _addTidIfNecessary(auth2, apiRequest), VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_);
}
function parseMode(mode) {
  switch (mode) {
    case "recoverEmail":
      return "RECOVER_EMAIL";
    case "resetPassword":
      return "PASSWORD_RESET";
    case "signIn":
      return "EMAIL_SIGNIN";
    case "verifyEmail":
      return "VERIFY_EMAIL";
    case "verifyAndChangeEmail":
      return "VERIFY_AND_CHANGE_EMAIL";
    case "revertSecondFactorAddition":
      return "REVERT_SECOND_FACTOR_ADDITION";
    default:
      return null;
  }
}
function parseDeepLink(url) {
  const link = querystringDecode(extractQuerystring(url))["link"];
  const doubleDeepLink = link ? querystringDecode(extractQuerystring(link))["deep_link_id"] : null;
  const iOSDeepLink = querystringDecode(extractQuerystring(url))["deep_link_id"];
  const iOSDoubleDeepLink = iOSDeepLink ? querystringDecode(extractQuerystring(iOSDeepLink))["link"] : null;
  return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
}
function parseActionCodeURL(link) {
  return ActionCodeURL.parseLink(link);
}
async function signUp(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signUp", _addTidIfNecessary(auth2, request));
}
function providerIdForResponse(response) {
  if (response.providerId) {
    return response.providerId;
  }
  if ("phoneNumber" in response) {
    return "phone";
  }
  return null;
}
async function signInAnonymously(auth2) {
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  const authInternal = _castAuth(auth2);
  await authInternal._initializationPromise;
  if (authInternal.currentUser?.isAnonymous) {
    return new UserCredentialImpl({
      user: authInternal.currentUser,
      providerId: null,
      operationType: "signIn"
      /* OperationType.SIGN_IN */
    });
  }
  const response = await signUp(authInternal, {
    returnSecureToken: true
  });
  const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn", response, true);
  await authInternal._updateCurrentUser(userCredential.user);
  return userCredential;
}
function _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential, user) {
  const idTokenProvider = operationType === "reauthenticate" ? credential._getReauthenticationResolver(auth2) : credential._getIdTokenResponse(auth2);
  return idTokenProvider.catch((error) => {
    if (error.code === `auth/${"multi-factor-auth-required"}`) {
      throw MultiFactorError._fromErrorAndOperation(auth2, error, operationType, user);
    }
    throw error;
  });
}
function providerDataAsNames(providerData) {
  return new Set(providerData.map(({ providerId }) => providerId).filter((pid) => !!pid));
}
async function unlink(user, providerId) {
  const userInternal = getModularInstance(user);
  await _assertLinkedStatus(true, userInternal, providerId);
  const { providerUserInfo } = await deleteLinkedAccounts(userInternal.auth, {
    idToken: await userInternal.getIdToken(),
    deleteProvider: [providerId]
  });
  const providersLeft = providerDataAsNames(providerUserInfo || []);
  userInternal.providerData = userInternal.providerData.filter((pd) => providersLeft.has(pd.providerId));
  if (!providersLeft.has(
    "phone"
    /* ProviderId.PHONE */
  )) {
    userInternal.phoneNumber = null;
  }
  await userInternal.auth._persistUserIfCurrent(userInternal);
  return userInternal;
}
async function _link(user, credential, bypassAuthState = false) {
  const response = await _logoutIfInvalidated(user, credential._linkToIdToken(user.auth, await user.getIdToken()), bypassAuthState);
  return UserCredentialImpl._forOperation(user, "link", response);
}
async function _assertLinkedStatus(expected, user, provider) {
  await _reloadWithoutSaving(user);
  const providerIds = providerDataAsNames(user.providerData);
  const code = expected === false ? "provider-already-linked" : "no-such-provider";
  _assert(providerIds.has(provider) === expected, user.auth, code);
}
async function _reauthenticate(user, credential, bypassAuthState = false) {
  const { auth: auth2 } = user;
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  const operationType = "reauthenticate";
  try {
    const response = await _logoutIfInvalidated(user, _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential, user), bypassAuthState);
    _assert(
      response.idToken,
      auth2,
      "internal-error"
      /* AuthErrorCode.INTERNAL_ERROR */
    );
    const parsed = _parseToken(response.idToken);
    _assert(
      parsed,
      auth2,
      "internal-error"
      /* AuthErrorCode.INTERNAL_ERROR */
    );
    const { sub: localId } = parsed;
    _assert(
      user.uid === localId,
      auth2,
      "user-mismatch"
      /* AuthErrorCode.USER_MISMATCH */
    );
    return UserCredentialImpl._forOperation(user, operationType, response);
  } catch (e) {
    if (e?.code === `auth/${"user-not-found"}`) {
      _fail(
        auth2,
        "user-mismatch"
        /* AuthErrorCode.USER_MISMATCH */
      );
    }
    throw e;
  }
}
async function _signInWithCredential(auth2, credential, bypassAuthState = false) {
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  const operationType = "signIn";
  const response = await _processCredentialSavingMfaContextIfNecessary(auth2, operationType, credential);
  const userCredential = await UserCredentialImpl._fromIdTokenResponse(auth2, operationType, response);
  if (!bypassAuthState) {
    await auth2._updateCurrentUser(userCredential.user);
  }
  return userCredential;
}
async function signInWithCredential(auth2, credential) {
  return _signInWithCredential(_castAuth(auth2), credential);
}
async function linkWithCredential(user, credential) {
  const userInternal = getModularInstance(user);
  await _assertLinkedStatus(false, userInternal, credential.providerId);
  return _link(userInternal, credential);
}
async function reauthenticateWithCredential(user, credential) {
  return _reauthenticate(getModularInstance(user), credential);
}
async function signInWithCustomToken$1(auth2, request) {
  return _performSignInRequest(auth2, "POST", "/v1/accounts:signInWithCustomToken", _addTidIfNecessary(auth2, request));
}
async function signInWithCustomToken(auth2, customToken) {
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  const authInternal = _castAuth(auth2);
  const response = await signInWithCustomToken$1(authInternal, {
    token: customToken,
    returnSecureToken: true
  });
  const cred = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn", response);
  await authInternal._updateCurrentUser(cred.user);
  return cred;
}
function _setActionCodeSettingsOnRequest(auth2, request, actionCodeSettings) {
  _assert(
    actionCodeSettings.url?.length > 0,
    auth2,
    "invalid-continue-uri"
    /* AuthErrorCode.INVALID_CONTINUE_URI */
  );
  _assert(
    typeof actionCodeSettings.dynamicLinkDomain === "undefined" || actionCodeSettings.dynamicLinkDomain.length > 0,
    auth2,
    "invalid-dynamic-link-domain"
    /* AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN */
  );
  _assert(
    typeof actionCodeSettings.linkDomain === "undefined" || actionCodeSettings.linkDomain.length > 0,
    auth2,
    "invalid-hosting-link-domain"
    /* AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN */
  );
  request.continueUrl = actionCodeSettings.url;
  request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;
  request.linkDomain = actionCodeSettings.linkDomain;
  request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;
  if (actionCodeSettings.iOS) {
    _assert(
      actionCodeSettings.iOS.bundleId.length > 0,
      auth2,
      "missing-ios-bundle-id"
      /* AuthErrorCode.MISSING_IOS_BUNDLE_ID */
    );
    request.iOSBundleId = actionCodeSettings.iOS.bundleId;
  }
  if (actionCodeSettings.android) {
    _assert(
      actionCodeSettings.android.packageName.length > 0,
      auth2,
      "missing-android-pkg-name"
      /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */
    );
    request.androidInstallApp = actionCodeSettings.android.installApp;
    request.androidMinimumVersionCode = actionCodeSettings.android.minimumVersion;
    request.androidPackageName = actionCodeSettings.android.packageName;
  }
}
async function recachePasswordPolicy(auth2) {
  const authInternal = _castAuth(auth2);
  if (authInternal._getPasswordPolicyInternal()) {
    await authInternal._updatePasswordPolicy();
  }
}
async function sendPasswordResetEmail(auth2, email, actionCodeSettings) {
  const authInternal = _castAuth(auth2);
  const request = {
    requestType: "PASSWORD_RESET",
    email,
    clientType: "CLIENT_TYPE_WEB"
    /* RecaptchaClientType.WEB */
  };
  if (actionCodeSettings) {
    _setActionCodeSettingsOnRequest(authInternal, request, actionCodeSettings);
  }
  await handleRecaptchaFlow(
    authInternal,
    request,
    "getOobCode",
    sendPasswordResetEmail$1,
    "EMAIL_PASSWORD_PROVIDER"
    /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
  );
}
async function confirmPasswordReset(auth2, oobCode, newPassword) {
  await resetPassword(getModularInstance(auth2), {
    oobCode,
    newPassword
  }).catch(async (error) => {
    if (error.code === `auth/${"password-does-not-meet-requirements"}`) {
      void recachePasswordPolicy(auth2);
    }
    throw error;
  });
}
async function applyActionCode(auth2, oobCode) {
  await applyActionCode$1(getModularInstance(auth2), { oobCode });
}
async function checkActionCode(auth2, oobCode) {
  const authModular = getModularInstance(auth2);
  const response = await resetPassword(authModular, { oobCode });
  const operation = response.requestType;
  _assert(
    operation,
    authModular,
    "internal-error"
    /* AuthErrorCode.INTERNAL_ERROR */
  );
  switch (operation) {
    case "EMAIL_SIGNIN":
      break;
    case "VERIFY_AND_CHANGE_EMAIL":
      _assert(
        response.newEmail,
        authModular,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      break;
    case "REVERT_SECOND_FACTOR_ADDITION":
      _assert(
        response.mfaInfo,
        authModular,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
    // fall through
    default:
      _assert(
        response.email,
        authModular,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
  }
  let multiFactorInfo = null;
  if (response.mfaInfo) {
    multiFactorInfo = MultiFactorInfoImpl._fromServerResponse(_castAuth(authModular), response.mfaInfo);
  }
  return {
    data: {
      email: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" ? response.newEmail : response.email) || null,
      previousEmail: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" ? response.email : response.newEmail) || null,
      multiFactorInfo
    },
    operation
  };
}
async function verifyPasswordResetCode(auth2, code) {
  const { data } = await checkActionCode(getModularInstance(auth2), code);
  return data.email;
}
async function createUserWithEmailAndPassword(auth2, email, password) {
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  const authInternal = _castAuth(auth2);
  const request = {
    returnSecureToken: true,
    email,
    password,
    clientType: "CLIENT_TYPE_WEB"
    /* RecaptchaClientType.WEB */
  };
  const signUpResponse = handleRecaptchaFlow(
    authInternal,
    request,
    "signUpPassword",
    signUp,
    "EMAIL_PASSWORD_PROVIDER"
    /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
  );
  const response = await signUpResponse.catch((error) => {
    if (error.code === `auth/${"password-does-not-meet-requirements"}`) {
      void recachePasswordPolicy(auth2);
    }
    throw error;
  });
  const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn", response);
  await authInternal._updateCurrentUser(userCredential.user);
  return userCredential;
}
function signInWithEmailAndPassword(auth2, email, password) {
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  return signInWithCredential(getModularInstance(auth2), EmailAuthProvider.credential(email, password)).catch(async (error) => {
    if (error.code === `auth/${"password-does-not-meet-requirements"}`) {
      void recachePasswordPolicy(auth2);
    }
    throw error;
  });
}
async function sendSignInLinkToEmail(auth2, email, actionCodeSettings) {
  const authInternal = _castAuth(auth2);
  const request = {
    requestType: "EMAIL_SIGNIN",
    email,
    clientType: "CLIENT_TYPE_WEB"
    /* RecaptchaClientType.WEB */
  };
  function setActionCodeSettings(request2, actionCodeSettings2) {
    _assert(
      actionCodeSettings2.handleCodeInApp,
      authInternal,
      "argument-error"
      /* AuthErrorCode.ARGUMENT_ERROR */
    );
    if (actionCodeSettings2) {
      _setActionCodeSettingsOnRequest(authInternal, request2, actionCodeSettings2);
    }
  }
  setActionCodeSettings(request, actionCodeSettings);
  await handleRecaptchaFlow(
    authInternal,
    request,
    "getOobCode",
    sendSignInLinkToEmail$1,
    "EMAIL_PASSWORD_PROVIDER"
    /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
  );
}
function isSignInWithEmailLink(auth2, emailLink) {
  const actionCodeUrl = ActionCodeURL.parseLink(emailLink);
  return actionCodeUrl?.operation === "EMAIL_SIGNIN";
}
async function signInWithEmailLink(auth2, email, emailLink) {
  if (_isFirebaseServerApp(auth2.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(auth2));
  }
  const authModular = getModularInstance(auth2);
  const credential = EmailAuthProvider.credentialWithLink(email, emailLink || _getCurrentUrl());
  _assert(
    credential._tenantId === (authModular.tenantId || null),
    authModular,
    "tenant-id-mismatch"
    /* AuthErrorCode.TENANT_ID_MISMATCH */
  );
  return signInWithCredential(authModular, credential);
}
async function createAuthUri(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:createAuthUri", _addTidIfNecessary(auth2, request));
}
async function fetchSignInMethodsForEmail(auth2, email) {
  const continueUri = _isHttpOrHttps() ? _getCurrentUrl() : "http://localhost";
  const request = {
    identifier: email,
    continueUri
  };
  const { signinMethods } = await createAuthUri(getModularInstance(auth2), request);
  return signinMethods || [];
}
async function sendEmailVerification(user, actionCodeSettings) {
  const userInternal = getModularInstance(user);
  const idToken = await user.getIdToken();
  const request = {
    requestType: "VERIFY_EMAIL",
    idToken
  };
  if (actionCodeSettings) {
    _setActionCodeSettingsOnRequest(userInternal.auth, request, actionCodeSettings);
  }
  const { email } = await sendEmailVerification$1(userInternal.auth, request);
  if (email !== user.email) {
    await user.reload();
  }
}
async function verifyBeforeUpdateEmail(user, newEmail, actionCodeSettings) {
  const userInternal = getModularInstance(user);
  const idToken = await user.getIdToken();
  const request = {
    requestType: "VERIFY_AND_CHANGE_EMAIL",
    idToken,
    newEmail
  };
  if (actionCodeSettings) {
    _setActionCodeSettingsOnRequest(userInternal.auth, request, actionCodeSettings);
  }
  const { email } = await verifyAndChangeEmail(userInternal.auth, request);
  if (email !== user.email) {
    await user.reload();
  }
}
async function updateProfile$1(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v1/accounts:update", request);
}
async function updateProfile(user, { displayName, photoURL: photoUrl }) {
  if (displayName === void 0 && photoUrl === void 0) {
    return;
  }
  const userInternal = getModularInstance(user);
  const idToken = await userInternal.getIdToken();
  const profileRequest = {
    idToken,
    displayName,
    photoUrl,
    returnSecureToken: true
  };
  const response = await _logoutIfInvalidated(userInternal, updateProfile$1(userInternal.auth, profileRequest));
  userInternal.displayName = response.displayName || null;
  userInternal.photoURL = response.photoUrl || null;
  const passwordProvider = userInternal.providerData.find(
    ({ providerId }) => providerId === "password"
    /* ProviderId.PASSWORD */
  );
  if (passwordProvider) {
    passwordProvider.displayName = userInternal.displayName;
    passwordProvider.photoURL = userInternal.photoURL;
  }
  await userInternal._updateTokensIfNecessary(response);
}
function updateEmail(user, newEmail) {
  const userInternal = getModularInstance(user);
  if (_isFirebaseServerApp(userInternal.auth.app)) {
    return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(userInternal.auth));
  }
  return updateEmailOrPassword(userInternal, newEmail, null);
}
function updatePassword(user, newPassword) {
  return updateEmailOrPassword(getModularInstance(user), null, newPassword);
}
async function updateEmailOrPassword(user, email, password) {
  const { auth: auth2 } = user;
  const idToken = await user.getIdToken();
  const request = {
    idToken,
    returnSecureToken: true
  };
  if (email) {
    request.email = email;
  }
  if (password) {
    request.password = password;
  }
  const response = await _logoutIfInvalidated(user, updateEmailPassword(auth2, request));
  await user._updateTokensIfNecessary(
    response,
    /* reload */
    true
  );
}
function _fromIdTokenResponse(idTokenResponse) {
  if (!idTokenResponse) {
    return null;
  }
  const { providerId } = idTokenResponse;
  const profile = idTokenResponse.rawUserInfo ? JSON.parse(idTokenResponse.rawUserInfo) : {};
  const isNewUser = idTokenResponse.isNewUser || idTokenResponse.kind === "identitytoolkit#SignupNewUserResponse";
  if (!providerId && idTokenResponse?.idToken) {
    const signInProvider = _parseToken(idTokenResponse.idToken)?.firebase?.["sign_in_provider"];
    if (signInProvider) {
      const filteredProviderId = signInProvider !== "anonymous" && signInProvider !== "custom" ? signInProvider : null;
      return new GenericAdditionalUserInfo(isNewUser, filteredProviderId);
    }
  }
  if (!providerId) {
    return null;
  }
  switch (providerId) {
    case "facebook.com":
      return new FacebookAdditionalUserInfo(isNewUser, profile);
    case "github.com":
      return new GithubAdditionalUserInfo(isNewUser, profile);
    case "google.com":
      return new GoogleAdditionalUserInfo(isNewUser, profile);
    case "twitter.com":
      return new TwitterAdditionalUserInfo(isNewUser, profile, idTokenResponse.screenName || null);
    case "custom":
    case "anonymous":
      return new GenericAdditionalUserInfo(isNewUser, null);
    default:
      return new GenericAdditionalUserInfo(isNewUser, providerId, profile);
  }
}
function getAdditionalUserInfo(userCredential) {
  const { user, _tokenResponse } = userCredential;
  if (user.isAnonymous && !_tokenResponse) {
    return {
      providerId: null,
      isNewUser: false,
      profile: null
    };
  }
  return _fromIdTokenResponse(_tokenResponse);
}
function setPersistence(auth2, persistence) {
  return getModularInstance(auth2).setPersistence(persistence);
}
function initializeRecaptchaConfig(auth2) {
  return _initializeRecaptchaConfig(auth2);
}
async function validatePassword(auth2, password) {
  const authInternal = _castAuth(auth2);
  return authInternal.validatePassword(password);
}
function onIdTokenChanged(auth2, nextOrObserver, error, completed) {
  return getModularInstance(auth2).onIdTokenChanged(nextOrObserver, error, completed);
}
function beforeAuthStateChanged(auth2, callback, onAbort) {
  return getModularInstance(auth2).beforeAuthStateChanged(callback, onAbort);
}
function onAuthStateChanged(auth2, nextOrObserver, error, completed) {
  return getModularInstance(auth2).onAuthStateChanged(nextOrObserver, error, completed);
}
function useDeviceLanguage(auth2) {
  getModularInstance(auth2).useDeviceLanguage();
}
function updateCurrentUser(auth2, user) {
  return getModularInstance(auth2).updateCurrentUser(user);
}
function signOut(auth2) {
  return getModularInstance(auth2).signOut();
}
function revokeAccessToken(auth2, token) {
  const authInternal = _castAuth(auth2);
  return authInternal.revokeAccessToken(token);
}
async function deleteUser(user) {
  return getModularInstance(user).delete();
}
function getMultiFactorResolver(auth2, error) {
  const authModular = getModularInstance(auth2);
  const errorInternal = error;
  _assert(
    error.customData.operationType,
    authModular,
    "argument-error"
    /* AuthErrorCode.ARGUMENT_ERROR */
  );
  _assert(
    errorInternal.customData._serverResponse?.mfaPendingCredential,
    authModular,
    "argument-error"
    /* AuthErrorCode.ARGUMENT_ERROR */
  );
  return MultiFactorResolverImpl._fromError(authModular, errorInternal);
}
function startEnrollTotpMfa(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v2/accounts/mfaEnrollment:start", _addTidIfNecessary(auth2, request));
}
function finalizeEnrollTotpMfa(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v2/accounts/mfaEnrollment:finalize", _addTidIfNecessary(auth2, request));
}
function withdrawMfa(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v2/accounts/mfaEnrollment:withdraw", _addTidIfNecessary(auth2, request));
}
function multiFactor(user) {
  const userModular = getModularInstance(user);
  if (!multiFactorUserCache.has(userModular)) {
    multiFactorUserCache.set(userModular, MultiFactorUserImpl._fromUser(userModular));
  }
  return multiFactorUserCache.get(userModular);
}
function getVersionForPlatform(clientPlatform) {
  switch (clientPlatform) {
    case "Node":
      return "node";
    case "ReactNative":
      return "rn";
    case "Worker":
      return "webworker";
    case "Cordova":
      return "cordova";
    case "WebExtension":
      return "web-extension";
    default:
      return void 0;
  }
}
function registerAuth(clientPlatform) {
  _registerComponent(new Component(
    "auth",
    (container, { options: deps }) => {
      const app2 = container.getProvider("app").getImmediate();
      const heartbeatServiceProvider = container.getProvider("heartbeat");
      const appCheckServiceProvider = container.getProvider("app-check-internal");
      const { apiKey, authDomain } = app2.options;
      _assert(apiKey && !apiKey.includes(":"), "invalid-api-key", { appName: app2.name });
      const config = {
        apiKey,
        authDomain,
        clientPlatform,
        apiHost: "identitytoolkit.googleapis.com",
        tokenApiHost: "securetoken.googleapis.com",
        apiScheme: "https",
        sdkClientVersion: _getClientVersion(clientPlatform)
      };
      const authInstance = new AuthImpl(app2, heartbeatServiceProvider, appCheckServiceProvider, config);
      _initializeAuthInstance(authInstance, deps);
      return authInstance;
    },
    "PUBLIC"
    /* ComponentType.PUBLIC */
  ).setInstantiationMode(
    "EXPLICIT"
    /* InstantiationMode.EXPLICIT */
  ).setInstanceCreatedCallback((container, _instanceIdentifier, _instance) => {
    const authInternalProvider = container.getProvider(
      "auth-internal"
      /* _ComponentName.AUTH_INTERNAL */
    );
    authInternalProvider.initialize();
  }));
  _registerComponent(new Component(
    "auth-internal",
    (container) => {
      const auth2 = _castAuth(container.getProvider(
        "auth"
        /* _ComponentName.AUTH */
      ).getImmediate());
      return ((auth3) => new AuthInterop(auth3))(auth2);
    },
    "PRIVATE"
    /* ComponentType.PRIVATE */
  ).setInstantiationMode(
    "EXPLICIT"
    /* InstantiationMode.EXPLICIT */
  ));
  registerVersion(name3, version3, getVersionForPlatform(clientPlatform));
  registerVersion(name3, version3, "esm2020");
}
function getAuth(app2 = getApp()) {
  const provider = _getProvider(app2, "auth");
  if (provider.isInitialized()) {
    return provider.getImmediate();
  }
  const auth2 = initializeAuth(app2);
  const authEmulatorHost = getDefaultEmulatorHost("auth");
  if (authEmulatorHost) {
    connectAuthEmulator(auth2, `http://${authEmulatorHost}`);
  }
  return auth2;
}
async function fail() {
  throw NOT_AVAILABLE_ERROR;
}
function finalizeSignInTotpMfa(auth2, request) {
  return _performApiRequest(auth2, "POST", "/v2/accounts/mfaSignIn:finalize", _addTidIfNecessary(auth2, request));
}
function _isEmptyString(input) {
  return typeof input === "undefined" || input?.length === 0;
}
var FactorId, ProviderId, SignInMethod, OperationType, ActionCodeOperation, debugErrorMap, prodErrorMap, _DEFAULT_AUTH_ERROR_FACTORY, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY, logClient, Delay, FetchProvider, SERVER_ERROR_MAP, CookieAuthProxiedEndpoints, DEFAULT_API_TIMEOUT_MS, NetworkTimeout, RecaptchaConfig, ProactiveRefresh, UserMetadata, StsTokenManager, UserImpl, instanceCache, InMemoryPersistence, inMemoryPersistence, PersistenceUserManager, AuthMiddlewareQueue, MINIMUM_MIN_PASSWORD_LENGTH, PasswordPolicyImpl, AuthImpl, Subscription, externalJSProvider, MockGreCAPTCHATopLevel, MockGreCAPTCHA, RECAPTCHA_ENTERPRISE_VERIFIER_TYPE, FAKE_TOKEN, RecaptchaEnterpriseVerifier, AuthCredential, EmailAuthCredential, IDP_REQUEST_URI$1, OAuthCredential, VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_, PhoneAuthCredential, ActionCodeURL, EmailAuthProvider, FederatedAuthProvider, BaseOAuthProvider, OAuthProvider, FacebookAuthProvider, GoogleAuthProvider, GithubAuthProvider, IDP_REQUEST_URI, SAMLAuthCredential, SAML_PROVIDER_PREFIX, SAMLAuthProvider, TwitterAuthProvider, UserCredentialImpl, MultiFactorError, MultiFactorInfoImpl, PhoneMultiFactorInfoImpl, TotpMultiFactorInfoImpl, GenericAdditionalUserInfo, FederatedAdditionalUserInfoWithUsername, FacebookAdditionalUserInfo, GithubAdditionalUserInfo, GoogleAdditionalUserInfo, TwitterAdditionalUserInfo, MultiFactorSessionImpl, MultiFactorResolverImpl, MultiFactorUserImpl, multiFactorUserCache, name3, version3, AuthInterop, NOT_AVAILABLE_ERROR, FailClass, browserLocalPersistence, browserSessionPersistence, browserCookiePersistence, indexedDBLocalPersistence, browserPopupRedirectResolver, PhoneAuthProvider, signInWithPhoneNumber, linkWithPhoneNumber, reauthenticateWithPhoneNumber, updatePhoneNumber, signInWithPopup, linkWithPopup, reauthenticateWithPopup, signInWithRedirect, linkWithRedirect, reauthenticateWithRedirect, getRedirectResult, RecaptchaVerifier, PhoneMultiFactorGenerator, MultiFactorAssertionImpl, TotpMultiFactorGenerator, TotpMultiFactorAssertionImpl, TotpSecret;
var init_totp_c8d207b9 = __esm({
  "node_modules/@firebase/auth/dist/node-esm/totp-c8d207b9.js"() {
    init_index_esm3();
    init_index_node_esm();
    init_index_esm();
    init_index_esm2();
    FactorId = {
      /** Phone as second factor */
      PHONE: "phone",
      TOTP: "totp"
    };
    ProviderId = {
      /** Facebook provider ID */
      FACEBOOK: "facebook.com",
      /** GitHub provider ID */
      GITHUB: "github.com",
      /** Google provider ID */
      GOOGLE: "google.com",
      /** Password provider */
      PASSWORD: "password",
      /** Phone provider */
      PHONE: "phone",
      /** Twitter provider ID */
      TWITTER: "twitter.com"
    };
    SignInMethod = {
      /** Email link sign in method */
      EMAIL_LINK: "emailLink",
      /** Email/password sign in method */
      EMAIL_PASSWORD: "password",
      /** Facebook sign in method */
      FACEBOOK: "facebook.com",
      /** GitHub sign in method */
      GITHUB: "github.com",
      /** Google sign in method */
      GOOGLE: "google.com",
      /** Phone sign in method */
      PHONE: "phone",
      /** Twitter sign in method */
      TWITTER: "twitter.com"
    };
    OperationType = {
      /** Operation involving linking an additional provider to an already signed-in user. */
      LINK: "link",
      /** Operation involving using a provider to reauthenticate an already signed-in user. */
      REAUTHENTICATE: "reauthenticate",
      /** Operation involving signing in a user. */
      SIGN_IN: "signIn"
    };
    ActionCodeOperation = {
      /** The email link sign-in action. */
      EMAIL_SIGNIN: "EMAIL_SIGNIN",
      /** The password reset action. */
      PASSWORD_RESET: "PASSWORD_RESET",
      /** The email revocation action. */
      RECOVER_EMAIL: "RECOVER_EMAIL",
      /** The revert second factor addition email action. */
      REVERT_SECOND_FACTOR_ADDITION: "REVERT_SECOND_FACTOR_ADDITION",
      /** The revert second factor addition email action. */
      VERIFY_AND_CHANGE_EMAIL: "VERIFY_AND_CHANGE_EMAIL",
      /** The email verification action. */
      VERIFY_EMAIL: "VERIFY_EMAIL"
    };
    debugErrorMap = _debugErrorMap;
    prodErrorMap = _prodErrorMap;
    _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory("auth", "Firebase", _prodErrorMap());
    AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY = {
      ADMIN_ONLY_OPERATION: "auth/admin-restricted-operation",
      ARGUMENT_ERROR: "auth/argument-error",
      APP_NOT_AUTHORIZED: "auth/app-not-authorized",
      APP_NOT_INSTALLED: "auth/app-not-installed",
      CAPTCHA_CHECK_FAILED: "auth/captcha-check-failed",
      CODE_EXPIRED: "auth/code-expired",
      CORDOVA_NOT_READY: "auth/cordova-not-ready",
      CORS_UNSUPPORTED: "auth/cors-unsupported",
      CREDENTIAL_ALREADY_IN_USE: "auth/credential-already-in-use",
      CREDENTIAL_MISMATCH: "auth/custom-token-mismatch",
      CREDENTIAL_TOO_OLD_LOGIN_AGAIN: "auth/requires-recent-login",
      DEPENDENT_SDK_INIT_BEFORE_AUTH: "auth/dependent-sdk-initialized-before-auth",
      DYNAMIC_LINK_NOT_ACTIVATED: "auth/dynamic-link-not-activated",
      EMAIL_CHANGE_NEEDS_VERIFICATION: "auth/email-change-needs-verification",
      EMAIL_EXISTS: "auth/email-already-in-use",
      EMULATOR_CONFIG_FAILED: "auth/emulator-config-failed",
      EXPIRED_OOB_CODE: "auth/expired-action-code",
      EXPIRED_POPUP_REQUEST: "auth/cancelled-popup-request",
      INTERNAL_ERROR: "auth/internal-error",
      INVALID_API_KEY: "auth/invalid-api-key",
      INVALID_APP_CREDENTIAL: "auth/invalid-app-credential",
      INVALID_APP_ID: "auth/invalid-app-id",
      INVALID_AUTH: "auth/invalid-user-token",
      INVALID_AUTH_EVENT: "auth/invalid-auth-event",
      INVALID_CERT_HASH: "auth/invalid-cert-hash",
      INVALID_CODE: "auth/invalid-verification-code",
      INVALID_CONTINUE_URI: "auth/invalid-continue-uri",
      INVALID_CORDOVA_CONFIGURATION: "auth/invalid-cordova-configuration",
      INVALID_CUSTOM_TOKEN: "auth/invalid-custom-token",
      INVALID_DYNAMIC_LINK_DOMAIN: "auth/invalid-dynamic-link-domain",
      INVALID_EMAIL: "auth/invalid-email",
      INVALID_EMULATOR_SCHEME: "auth/invalid-emulator-scheme",
      INVALID_IDP_RESPONSE: "auth/invalid-credential",
      INVALID_LOGIN_CREDENTIALS: "auth/invalid-credential",
      INVALID_MESSAGE_PAYLOAD: "auth/invalid-message-payload",
      INVALID_MFA_SESSION: "auth/invalid-multi-factor-session",
      INVALID_OAUTH_CLIENT_ID: "auth/invalid-oauth-client-id",
      INVALID_OAUTH_PROVIDER: "auth/invalid-oauth-provider",
      INVALID_OOB_CODE: "auth/invalid-action-code",
      INVALID_ORIGIN: "auth/unauthorized-domain",
      INVALID_PASSWORD: "auth/wrong-password",
      INVALID_PERSISTENCE: "auth/invalid-persistence-type",
      INVALID_PHONE_NUMBER: "auth/invalid-phone-number",
      INVALID_PROVIDER_ID: "auth/invalid-provider-id",
      INVALID_RECIPIENT_EMAIL: "auth/invalid-recipient-email",
      INVALID_SENDER: "auth/invalid-sender",
      INVALID_SESSION_INFO: "auth/invalid-verification-id",
      INVALID_TENANT_ID: "auth/invalid-tenant-id",
      MFA_INFO_NOT_FOUND: "auth/multi-factor-info-not-found",
      MFA_REQUIRED: "auth/multi-factor-auth-required",
      MISSING_ANDROID_PACKAGE_NAME: "auth/missing-android-pkg-name",
      MISSING_APP_CREDENTIAL: "auth/missing-app-credential",
      MISSING_AUTH_DOMAIN: "auth/auth-domain-config-required",
      MISSING_CODE: "auth/missing-verification-code",
      MISSING_CONTINUE_URI: "auth/missing-continue-uri",
      MISSING_IFRAME_START: "auth/missing-iframe-start",
      MISSING_IOS_BUNDLE_ID: "auth/missing-ios-bundle-id",
      MISSING_OR_INVALID_NONCE: "auth/missing-or-invalid-nonce",
      MISSING_MFA_INFO: "auth/missing-multi-factor-info",
      MISSING_MFA_SESSION: "auth/missing-multi-factor-session",
      MISSING_PHONE_NUMBER: "auth/missing-phone-number",
      MISSING_PASSWORD: "auth/missing-password",
      MISSING_SESSION_INFO: "auth/missing-verification-id",
      MODULE_DESTROYED: "auth/app-deleted",
      NEED_CONFIRMATION: "auth/account-exists-with-different-credential",
      NETWORK_REQUEST_FAILED: "auth/network-request-failed",
      NULL_USER: "auth/null-user",
      NO_AUTH_EVENT: "auth/no-auth-event",
      NO_SUCH_PROVIDER: "auth/no-such-provider",
      OPERATION_NOT_ALLOWED: "auth/operation-not-allowed",
      OPERATION_NOT_SUPPORTED: "auth/operation-not-supported-in-this-environment",
      POPUP_BLOCKED: "auth/popup-blocked",
      POPUP_CLOSED_BY_USER: "auth/popup-closed-by-user",
      PROVIDER_ALREADY_LINKED: "auth/provider-already-linked",
      QUOTA_EXCEEDED: "auth/quota-exceeded",
      REDIRECT_CANCELLED_BY_USER: "auth/redirect-cancelled-by-user",
      REDIRECT_OPERATION_PENDING: "auth/redirect-operation-pending",
      REJECTED_CREDENTIAL: "auth/rejected-credential",
      SECOND_FACTOR_ALREADY_ENROLLED: "auth/second-factor-already-in-use",
      SECOND_FACTOR_LIMIT_EXCEEDED: "auth/maximum-second-factor-count-exceeded",
      TENANT_ID_MISMATCH: "auth/tenant-id-mismatch",
      TIMEOUT: "auth/timeout",
      TOKEN_EXPIRED: "auth/user-token-expired",
      TOO_MANY_ATTEMPTS_TRY_LATER: "auth/too-many-requests",
      UNAUTHORIZED_DOMAIN: "auth/unauthorized-continue-uri",
      UNSUPPORTED_FIRST_FACTOR: "auth/unsupported-first-factor",
      UNSUPPORTED_PERSISTENCE: "auth/unsupported-persistence-type",
      UNSUPPORTED_TENANT_OPERATION: "auth/unsupported-tenant-operation",
      UNVERIFIED_EMAIL: "auth/unverified-email",
      USER_CANCELLED: "auth/user-cancelled",
      USER_DELETED: "auth/user-not-found",
      USER_DISABLED: "auth/user-disabled",
      USER_MISMATCH: "auth/user-mismatch",
      USER_SIGNED_OUT: "auth/user-signed-out",
      WEAK_PASSWORD: "auth/weak-password",
      WEB_STORAGE_UNSUPPORTED: "auth/web-storage-unsupported",
      ALREADY_INITIALIZED: "auth/already-initialized",
      RECAPTCHA_NOT_ENABLED: "auth/recaptcha-not-enabled",
      MISSING_RECAPTCHA_TOKEN: "auth/missing-recaptcha-token",
      INVALID_RECAPTCHA_TOKEN: "auth/invalid-recaptcha-token",
      INVALID_RECAPTCHA_ACTION: "auth/invalid-recaptcha-action",
      MISSING_CLIENT_TYPE: "auth/missing-client-type",
      MISSING_RECAPTCHA_VERSION: "auth/missing-recaptcha-version",
      INVALID_RECAPTCHA_VERSION: "auth/invalid-recaptcha-version",
      INVALID_REQ_TYPE: "auth/invalid-req-type",
      INVALID_HOSTING_LINK_DOMAIN: "auth/invalid-hosting-link-domain"
    };
    logClient = new Logger("@firebase/auth");
    Delay = class {
      constructor(shortDelay, longDelay) {
        this.shortDelay = shortDelay;
        this.longDelay = longDelay;
        debugAssert(longDelay > shortDelay, "Short delay should be less than long delay!");
        this.isMobile = isMobileCordova() || isReactNative();
      }
      get() {
        if (!_isOnline()) {
          return Math.min(5e3, this.shortDelay);
        }
        return this.isMobile ? this.longDelay : this.shortDelay;
      }
    };
    FetchProvider = class {
      static initialize(fetchImpl, headersImpl, responseImpl) {
        this.fetchImpl = fetchImpl;
        if (headersImpl) {
          this.headersImpl = headersImpl;
        }
        if (responseImpl) {
          this.responseImpl = responseImpl;
        }
      }
      static fetch() {
        if (this.fetchImpl) {
          return this.fetchImpl;
        }
        if (typeof self !== "undefined" && "fetch" in self) {
          return self.fetch;
        }
        if (typeof globalThis !== "undefined" && globalThis.fetch) {
          return globalThis.fetch;
        }
        if (typeof fetch !== "undefined") {
          return fetch;
        }
        debugFail("Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
      }
      static headers() {
        if (this.headersImpl) {
          return this.headersImpl;
        }
        if (typeof self !== "undefined" && "Headers" in self) {
          return self.Headers;
        }
        if (typeof globalThis !== "undefined" && globalThis.Headers) {
          return globalThis.Headers;
        }
        if (typeof Headers !== "undefined") {
          return Headers;
        }
        debugFail("Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
      }
      static response() {
        if (this.responseImpl) {
          return this.responseImpl;
        }
        if (typeof self !== "undefined" && "Response" in self) {
          return self.Response;
        }
        if (typeof globalThis !== "undefined" && globalThis.Response) {
          return globalThis.Response;
        }
        if (typeof Response !== "undefined") {
          return Response;
        }
        debugFail("Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
      }
    };
    SERVER_ERROR_MAP = {
      // Custom token errors.
      [
        "CREDENTIAL_MISMATCH"
        /* ServerError.CREDENTIAL_MISMATCH */
      ]: "custom-token-mismatch",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_CUSTOM_TOKEN"
        /* ServerError.MISSING_CUSTOM_TOKEN */
      ]: "internal-error",
      // Create Auth URI errors.
      [
        "INVALID_IDENTIFIER"
        /* ServerError.INVALID_IDENTIFIER */
      ]: "invalid-email",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_CONTINUE_URI"
        /* ServerError.MISSING_CONTINUE_URI */
      ]: "internal-error",
      // Sign in with email and password errors (some apply to sign up too).
      [
        "INVALID_PASSWORD"
        /* ServerError.INVALID_PASSWORD */
      ]: "wrong-password",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_PASSWORD"
        /* ServerError.MISSING_PASSWORD */
      ]: "missing-password",
      // Thrown if Email Enumeration Protection is enabled in the project and the email or password is
      // invalid.
      [
        "INVALID_LOGIN_CREDENTIALS"
        /* ServerError.INVALID_LOGIN_CREDENTIALS */
      ]: "invalid-credential",
      // Sign up with email and password errors.
      [
        "EMAIL_EXISTS"
        /* ServerError.EMAIL_EXISTS */
      ]: "email-already-in-use",
      [
        "PASSWORD_LOGIN_DISABLED"
        /* ServerError.PASSWORD_LOGIN_DISABLED */
      ]: "operation-not-allowed",
      // Verify assertion for sign in with credential errors:
      [
        "INVALID_IDP_RESPONSE"
        /* ServerError.INVALID_IDP_RESPONSE */
      ]: "invalid-credential",
      [
        "INVALID_PENDING_TOKEN"
        /* ServerError.INVALID_PENDING_TOKEN */
      ]: "invalid-credential",
      [
        "FEDERATED_USER_ID_ALREADY_LINKED"
        /* ServerError.FEDERATED_USER_ID_ALREADY_LINKED */
      ]: "credential-already-in-use",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_REQ_TYPE"
        /* ServerError.MISSING_REQ_TYPE */
      ]: "internal-error",
      // Send Password reset email errors:
      [
        "EMAIL_NOT_FOUND"
        /* ServerError.EMAIL_NOT_FOUND */
      ]: "user-not-found",
      [
        "RESET_PASSWORD_EXCEED_LIMIT"
        /* ServerError.RESET_PASSWORD_EXCEED_LIMIT */
      ]: "too-many-requests",
      [
        "EXPIRED_OOB_CODE"
        /* ServerError.EXPIRED_OOB_CODE */
      ]: "expired-action-code",
      [
        "INVALID_OOB_CODE"
        /* ServerError.INVALID_OOB_CODE */
      ]: "invalid-action-code",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_OOB_CODE"
        /* ServerError.MISSING_OOB_CODE */
      ]: "internal-error",
      // Operations that require ID token in request:
      [
        "CREDENTIAL_TOO_OLD_LOGIN_AGAIN"
        /* ServerError.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */
      ]: "requires-recent-login",
      [
        "INVALID_ID_TOKEN"
        /* ServerError.INVALID_ID_TOKEN */
      ]: "invalid-user-token",
      [
        "TOKEN_EXPIRED"
        /* ServerError.TOKEN_EXPIRED */
      ]: "user-token-expired",
      [
        "USER_NOT_FOUND"
        /* ServerError.USER_NOT_FOUND */
      ]: "user-token-expired",
      // Other errors.
      [
        "TOO_MANY_ATTEMPTS_TRY_LATER"
        /* ServerError.TOO_MANY_ATTEMPTS_TRY_LATER */
      ]: "too-many-requests",
      [
        "PASSWORD_DOES_NOT_MEET_REQUIREMENTS"
        /* ServerError.PASSWORD_DOES_NOT_MEET_REQUIREMENTS */
      ]: "password-does-not-meet-requirements",
      // Phone Auth related errors.
      [
        "INVALID_CODE"
        /* ServerError.INVALID_CODE */
      ]: "invalid-verification-code",
      [
        "INVALID_SESSION_INFO"
        /* ServerError.INVALID_SESSION_INFO */
      ]: "invalid-verification-id",
      [
        "INVALID_TEMPORARY_PROOF"
        /* ServerError.INVALID_TEMPORARY_PROOF */
      ]: "invalid-credential",
      [
        "MISSING_SESSION_INFO"
        /* ServerError.MISSING_SESSION_INFO */
      ]: "missing-verification-id",
      [
        "SESSION_EXPIRED"
        /* ServerError.SESSION_EXPIRED */
      ]: "code-expired",
      // Other action code errors when additional settings passed.
      // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.
      // This is OK as this error will be caught by client side validation.
      [
        "MISSING_ANDROID_PACKAGE_NAME"
        /* ServerError.MISSING_ANDROID_PACKAGE_NAME */
      ]: "missing-android-pkg-name",
      [
        "UNAUTHORIZED_DOMAIN"
        /* ServerError.UNAUTHORIZED_DOMAIN */
      ]: "unauthorized-continue-uri",
      // getProjectConfig errors when clientId is passed.
      [
        "INVALID_OAUTH_CLIENT_ID"
        /* ServerError.INVALID_OAUTH_CLIENT_ID */
      ]: "invalid-oauth-client-id",
      // User actions (sign-up or deletion) disabled errors.
      [
        "ADMIN_ONLY_OPERATION"
        /* ServerError.ADMIN_ONLY_OPERATION */
      ]: "admin-restricted-operation",
      // Multi factor related errors.
      [
        "INVALID_MFA_PENDING_CREDENTIAL"
        /* ServerError.INVALID_MFA_PENDING_CREDENTIAL */
      ]: "invalid-multi-factor-session",
      [
        "MFA_ENROLLMENT_NOT_FOUND"
        /* ServerError.MFA_ENROLLMENT_NOT_FOUND */
      ]: "multi-factor-info-not-found",
      [
        "MISSING_MFA_ENROLLMENT_ID"
        /* ServerError.MISSING_MFA_ENROLLMENT_ID */
      ]: "missing-multi-factor-info",
      [
        "MISSING_MFA_PENDING_CREDENTIAL"
        /* ServerError.MISSING_MFA_PENDING_CREDENTIAL */
      ]: "missing-multi-factor-session",
      [
        "SECOND_FACTOR_EXISTS"
        /* ServerError.SECOND_FACTOR_EXISTS */
      ]: "second-factor-already-in-use",
      [
        "SECOND_FACTOR_LIMIT_EXCEEDED"
        /* ServerError.SECOND_FACTOR_LIMIT_EXCEEDED */
      ]: "maximum-second-factor-count-exceeded",
      // Blocking functions related errors.
      [
        "BLOCKING_FUNCTION_ERROR_RESPONSE"
        /* ServerError.BLOCKING_FUNCTION_ERROR_RESPONSE */
      ]: "internal-error",
      // Recaptcha related errors.
      [
        "RECAPTCHA_NOT_ENABLED"
        /* ServerError.RECAPTCHA_NOT_ENABLED */
      ]: "recaptcha-not-enabled",
      [
        "MISSING_RECAPTCHA_TOKEN"
        /* ServerError.MISSING_RECAPTCHA_TOKEN */
      ]: "missing-recaptcha-token",
      [
        "INVALID_RECAPTCHA_TOKEN"
        /* ServerError.INVALID_RECAPTCHA_TOKEN */
      ]: "invalid-recaptcha-token",
      [
        "INVALID_RECAPTCHA_ACTION"
        /* ServerError.INVALID_RECAPTCHA_ACTION */
      ]: "invalid-recaptcha-action",
      [
        "MISSING_CLIENT_TYPE"
        /* ServerError.MISSING_CLIENT_TYPE */
      ]: "missing-client-type",
      [
        "MISSING_RECAPTCHA_VERSION"
        /* ServerError.MISSING_RECAPTCHA_VERSION */
      ]: "missing-recaptcha-version",
      [
        "INVALID_RECAPTCHA_VERSION"
        /* ServerError.INVALID_RECAPTCHA_VERSION */
      ]: "invalid-recaptcha-version",
      [
        "INVALID_REQ_TYPE"
        /* ServerError.INVALID_REQ_TYPE */
      ]: "invalid-req-type"
      /* AuthErrorCode.INVALID_REQ_TYPE */
    };
    CookieAuthProxiedEndpoints = [
      "/v1/accounts:signInWithCustomToken",
      "/v1/accounts:signInWithEmailLink",
      "/v1/accounts:signInWithIdp",
      "/v1/accounts:signInWithPassword",
      "/v1/accounts:signInWithPhoneNumber",
      "/v1/token"
      /* Endpoint.TOKEN */
    ];
    DEFAULT_API_TIMEOUT_MS = new Delay(3e4, 6e4);
    NetworkTimeout = class {
      clearNetworkTimeout() {
        clearTimeout(this.timer);
      }
      constructor(auth2) {
        this.auth = auth2;
        this.timer = null;
        this.promise = new Promise((_, reject) => {
          this.timer = setTimeout(() => {
            return reject(_createError(
              this.auth,
              "network-request-failed"
              /* AuthErrorCode.NETWORK_REQUEST_FAILED */
            ));
          }, DEFAULT_API_TIMEOUT_MS.get());
        });
      }
    };
    RecaptchaConfig = class {
      constructor(response) {
        this.siteKey = "";
        this.recaptchaEnforcementState = [];
        if (response.recaptchaKey === void 0) {
          throw new Error("recaptchaKey undefined");
        }
        this.siteKey = response.recaptchaKey.split("/")[3];
        this.recaptchaEnforcementState = response.recaptchaEnforcementState;
      }
      /**
       * Returns the reCAPTCHA Enterprise enforcement state for the given provider.
       *
       * @param providerStr - The provider whose enforcement state is to be returned.
       * @returns The reCAPTCHA Enterprise enforcement state for the given provider.
       */
      getProviderEnforcementState(providerStr) {
        if (!this.recaptchaEnforcementState || this.recaptchaEnforcementState.length === 0) {
          return null;
        }
        for (const recaptchaEnforcementState of this.recaptchaEnforcementState) {
          if (recaptchaEnforcementState.provider && recaptchaEnforcementState.provider === providerStr) {
            return _parseEnforcementState(recaptchaEnforcementState.enforcementState);
          }
        }
        return null;
      }
      /**
       * Returns true if the reCAPTCHA Enterprise enforcement state for the provider is set to ENFORCE or AUDIT.
       *
       * @param providerStr - The provider whose enablement state is to be returned.
       * @returns Whether or not reCAPTCHA Enterprise protection is enabled for the given provider.
       */
      isProviderEnabled(providerStr) {
        return this.getProviderEnforcementState(providerStr) === "ENFORCE" || this.getProviderEnforcementState(providerStr) === "AUDIT";
      }
      /**
       * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise
       * returns false.
       *
       * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.
       */
      isAnyProviderEnabled() {
        return this.isProviderEnabled(
          "EMAIL_PASSWORD_PROVIDER"
          /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
        ) || this.isProviderEnabled(
          "PHONE_PROVIDER"
          /* RecaptchaAuthProvider.PHONE_PROVIDER */
        );
      }
    };
    ProactiveRefresh = class {
      constructor(user) {
        this.user = user;
        this.isRunning = false;
        this.timerId = null;
        this.errorBackoff = 3e4;
      }
      _start() {
        if (this.isRunning) {
          return;
        }
        this.isRunning = true;
        this.schedule();
      }
      _stop() {
        if (!this.isRunning) {
          return;
        }
        this.isRunning = false;
        if (this.timerId !== null) {
          clearTimeout(this.timerId);
        }
      }
      getInterval(wasError) {
        if (wasError) {
          const interval = this.errorBackoff;
          this.errorBackoff = Math.min(
            this.errorBackoff * 2,
            96e4
            /* Duration.RETRY_BACKOFF_MAX */
          );
          return interval;
        } else {
          this.errorBackoff = 3e4;
          const expTime = this.user.stsTokenManager.expirationTime ?? 0;
          const interval = expTime - Date.now() - 3e5;
          return Math.max(0, interval);
        }
      }
      schedule(wasError = false) {
        if (!this.isRunning) {
          return;
        }
        const interval = this.getInterval(wasError);
        this.timerId = setTimeout(async () => {
          await this.iteration();
        }, interval);
      }
      async iteration() {
        try {
          await this.user.getIdToken(true);
        } catch (e) {
          if (e?.code === `auth/${"network-request-failed"}`) {
            this.schedule(
              /* wasError */
              true
            );
          }
          return;
        }
        this.schedule();
      }
    };
    UserMetadata = class {
      constructor(createdAt, lastLoginAt) {
        this.createdAt = createdAt;
        this.lastLoginAt = lastLoginAt;
        this._initializeTime();
      }
      _initializeTime() {
        this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);
        this.creationTime = utcTimestampToDateString(this.createdAt);
      }
      _copy(metadata) {
        this.createdAt = metadata.createdAt;
        this.lastLoginAt = metadata.lastLoginAt;
        this._initializeTime();
      }
      toJSON() {
        return {
          createdAt: this.createdAt,
          lastLoginAt: this.lastLoginAt
        };
      }
    };
    StsTokenManager = class _StsTokenManager {
      constructor() {
        this.refreshToken = null;
        this.accessToken = null;
        this.expirationTime = null;
      }
      get isExpired() {
        return !this.expirationTime || Date.now() > this.expirationTime - 3e4;
      }
      updateFromServerResponse(response) {
        _assert(
          response.idToken,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        _assert(
          typeof response.idToken !== "undefined",
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        _assert(
          typeof response.refreshToken !== "undefined",
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const expiresIn = "expiresIn" in response && typeof response.expiresIn !== "undefined" ? Number(response.expiresIn) : _tokenExpiresIn(response.idToken);
        this.updateTokensAndExpiration(response.idToken, response.refreshToken, expiresIn);
      }
      updateFromIdToken(idToken) {
        _assert(
          idToken.length !== 0,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const expiresIn = _tokenExpiresIn(idToken);
        this.updateTokensAndExpiration(idToken, null, expiresIn);
      }
      async getToken(auth2, forceRefresh = false) {
        if (!forceRefresh && this.accessToken && !this.isExpired) {
          return this.accessToken;
        }
        _assert(
          this.refreshToken,
          auth2,
          "user-token-expired"
          /* AuthErrorCode.TOKEN_EXPIRED */
        );
        if (this.refreshToken) {
          await this.refresh(auth2, this.refreshToken);
          return this.accessToken;
        }
        return null;
      }
      clearRefreshToken() {
        this.refreshToken = null;
      }
      async refresh(auth2, oldToken) {
        const { accessToken, refreshToken, expiresIn } = await requestStsToken(auth2, oldToken);
        this.updateTokensAndExpiration(accessToken, refreshToken, Number(expiresIn));
      }
      updateTokensAndExpiration(accessToken, refreshToken, expiresInSec) {
        this.refreshToken = refreshToken || null;
        this.accessToken = accessToken || null;
        this.expirationTime = Date.now() + expiresInSec * 1e3;
      }
      static fromJSON(appName, object) {
        const { refreshToken, accessToken, expirationTime } = object;
        const manager = new _StsTokenManager();
        if (refreshToken) {
          _assert(typeof refreshToken === "string", "internal-error", {
            appName
          });
          manager.refreshToken = refreshToken;
        }
        if (accessToken) {
          _assert(typeof accessToken === "string", "internal-error", {
            appName
          });
          manager.accessToken = accessToken;
        }
        if (expirationTime) {
          _assert(typeof expirationTime === "number", "internal-error", {
            appName
          });
          manager.expirationTime = expirationTime;
        }
        return manager;
      }
      toJSON() {
        return {
          refreshToken: this.refreshToken,
          accessToken: this.accessToken,
          expirationTime: this.expirationTime
        };
      }
      _assign(stsTokenManager) {
        this.accessToken = stsTokenManager.accessToken;
        this.refreshToken = stsTokenManager.refreshToken;
        this.expirationTime = stsTokenManager.expirationTime;
      }
      _clone() {
        return Object.assign(new _StsTokenManager(), this.toJSON());
      }
      _performRefresh() {
        return debugFail("not implemented");
      }
    };
    UserImpl = class _UserImpl {
      constructor({ uid, auth: auth2, stsTokenManager, ...opt }) {
        this.providerId = "firebase";
        this.proactiveRefresh = new ProactiveRefresh(this);
        this.reloadUserInfo = null;
        this.reloadListener = null;
        this.uid = uid;
        this.auth = auth2;
        this.stsTokenManager = stsTokenManager;
        this.accessToken = stsTokenManager.accessToken;
        this.displayName = opt.displayName || null;
        this.email = opt.email || null;
        this.emailVerified = opt.emailVerified || false;
        this.phoneNumber = opt.phoneNumber || null;
        this.photoURL = opt.photoURL || null;
        this.isAnonymous = opt.isAnonymous || false;
        this.tenantId = opt.tenantId || null;
        this.providerData = opt.providerData ? [...opt.providerData] : [];
        this.metadata = new UserMetadata(opt.createdAt || void 0, opt.lastLoginAt || void 0);
      }
      async getIdToken(forceRefresh) {
        const accessToken = await _logoutIfInvalidated(this, this.stsTokenManager.getToken(this.auth, forceRefresh));
        _assert(
          accessToken,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        if (this.accessToken !== accessToken) {
          this.accessToken = accessToken;
          await this.auth._persistUserIfCurrent(this);
          this.auth._notifyListenersIfCurrent(this);
        }
        return accessToken;
      }
      getIdTokenResult(forceRefresh) {
        return getIdTokenResult(this, forceRefresh);
      }
      reload() {
        return reload(this);
      }
      _assign(user) {
        if (this === user) {
          return;
        }
        _assert(
          this.uid === user.uid,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        this.displayName = user.displayName;
        this.photoURL = user.photoURL;
        this.email = user.email;
        this.emailVerified = user.emailVerified;
        this.phoneNumber = user.phoneNumber;
        this.isAnonymous = user.isAnonymous;
        this.tenantId = user.tenantId;
        this.providerData = user.providerData.map((userInfo) => ({ ...userInfo }));
        this.metadata._copy(user.metadata);
        this.stsTokenManager._assign(user.stsTokenManager);
      }
      _clone(auth2) {
        const newUser = new _UserImpl({
          ...this,
          auth: auth2,
          stsTokenManager: this.stsTokenManager._clone()
        });
        newUser.metadata._copy(this.metadata);
        return newUser;
      }
      _onReload(callback) {
        _assert(
          !this.reloadListener,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        this.reloadListener = callback;
        if (this.reloadUserInfo) {
          this._notifyReloadListener(this.reloadUserInfo);
          this.reloadUserInfo = null;
        }
      }
      _notifyReloadListener(userInfo) {
        if (this.reloadListener) {
          this.reloadListener(userInfo);
        } else {
          this.reloadUserInfo = userInfo;
        }
      }
      _startProactiveRefresh() {
        this.proactiveRefresh._start();
      }
      _stopProactiveRefresh() {
        this.proactiveRefresh._stop();
      }
      async _updateTokensIfNecessary(response, reload2 = false) {
        let tokensRefreshed = false;
        if (response.idToken && response.idToken !== this.stsTokenManager.accessToken) {
          this.stsTokenManager.updateFromServerResponse(response);
          tokensRefreshed = true;
        }
        if (reload2) {
          await _reloadWithoutSaving(this);
        }
        await this.auth._persistUserIfCurrent(this);
        if (tokensRefreshed) {
          this.auth._notifyListenersIfCurrent(this);
        }
      }
      async delete() {
        if (_isFirebaseServerApp(this.auth.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(this.auth));
        }
        const idToken = await this.getIdToken();
        await _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken }));
        this.stsTokenManager.clearRefreshToken();
        return this.auth.signOut();
      }
      toJSON() {
        return {
          uid: this.uid,
          email: this.email || void 0,
          emailVerified: this.emailVerified,
          displayName: this.displayName || void 0,
          isAnonymous: this.isAnonymous,
          photoURL: this.photoURL || void 0,
          phoneNumber: this.phoneNumber || void 0,
          tenantId: this.tenantId || void 0,
          providerData: this.providerData.map((userInfo) => ({ ...userInfo })),
          stsTokenManager: this.stsTokenManager.toJSON(),
          // Redirect event ID must be maintained in case there is a pending
          // redirect event.
          _redirectEventId: this._redirectEventId,
          ...this.metadata.toJSON(),
          // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):
          apiKey: this.auth.config.apiKey,
          appName: this.auth.name
          // Missing authDomain will be tolerated by the legacy SDK.
          // stsTokenManager.apiKey isn't actually required (despite the legacy SDK persisting it).
        };
      }
      get refreshToken() {
        return this.stsTokenManager.refreshToken || "";
      }
      static _fromJSON(auth2, object) {
        const displayName = object.displayName ?? void 0;
        const email = object.email ?? void 0;
        const phoneNumber = object.phoneNumber ?? void 0;
        const photoURL = object.photoURL ?? void 0;
        const tenantId = object.tenantId ?? void 0;
        const _redirectEventId = object._redirectEventId ?? void 0;
        const createdAt = object.createdAt ?? void 0;
        const lastLoginAt = object.lastLoginAt ?? void 0;
        const { uid, emailVerified, isAnonymous, providerData, stsTokenManager: plainObjectTokenManager } = object;
        _assert(
          uid && plainObjectTokenManager,
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const stsTokenManager = StsTokenManager.fromJSON(this.name, plainObjectTokenManager);
        _assert(
          typeof uid === "string",
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        assertStringOrUndefined(displayName, auth2.name);
        assertStringOrUndefined(email, auth2.name);
        _assert(
          typeof emailVerified === "boolean",
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        _assert(
          typeof isAnonymous === "boolean",
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        assertStringOrUndefined(phoneNumber, auth2.name);
        assertStringOrUndefined(photoURL, auth2.name);
        assertStringOrUndefined(tenantId, auth2.name);
        assertStringOrUndefined(_redirectEventId, auth2.name);
        assertStringOrUndefined(createdAt, auth2.name);
        assertStringOrUndefined(lastLoginAt, auth2.name);
        const user = new _UserImpl({
          uid,
          auth: auth2,
          email,
          emailVerified,
          displayName,
          isAnonymous,
          photoURL,
          phoneNumber,
          tenantId,
          stsTokenManager,
          createdAt,
          lastLoginAt
        });
        if (providerData && Array.isArray(providerData)) {
          user.providerData = providerData.map((userInfo) => ({ ...userInfo }));
        }
        if (_redirectEventId) {
          user._redirectEventId = _redirectEventId;
        }
        return user;
      }
      /**
       * Initialize a User from an idToken server response
       * @param auth
       * @param idTokenResponse
       */
      static async _fromIdTokenResponse(auth2, idTokenResponse, isAnonymous = false) {
        const stsTokenManager = new StsTokenManager();
        stsTokenManager.updateFromServerResponse(idTokenResponse);
        const user = new _UserImpl({
          uid: idTokenResponse.localId,
          auth: auth2,
          stsTokenManager,
          isAnonymous
        });
        await _reloadWithoutSaving(user);
        return user;
      }
      /**
       * Initialize a User from an idToken server response
       * @param auth
       * @param idTokenResponse
       */
      static async _fromGetAccountInfoResponse(auth2, response, idToken) {
        const coreAccount = response.users[0];
        _assert(
          coreAccount.localId !== void 0,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const providerData = coreAccount.providerUserInfo !== void 0 ? extractProviderData(coreAccount.providerUserInfo) : [];
        const isAnonymous = !(coreAccount.email && coreAccount.passwordHash) && !providerData?.length;
        const stsTokenManager = new StsTokenManager();
        stsTokenManager.updateFromIdToken(idToken);
        const user = new _UserImpl({
          uid: coreAccount.localId,
          auth: auth2,
          stsTokenManager,
          isAnonymous
        });
        const updates = {
          uid: coreAccount.localId,
          displayName: coreAccount.displayName || null,
          photoURL: coreAccount.photoUrl || null,
          email: coreAccount.email || null,
          emailVerified: coreAccount.emailVerified || false,
          phoneNumber: coreAccount.phoneNumber || null,
          tenantId: coreAccount.tenantId || null,
          providerData,
          metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),
          isAnonymous: !(coreAccount.email && coreAccount.passwordHash) && !providerData?.length
        };
        Object.assign(user, updates);
        return user;
      }
    };
    instanceCache = /* @__PURE__ */ new Map();
    InMemoryPersistence = class {
      constructor() {
        this.type = "NONE";
        this.storage = {};
      }
      async _isAvailable() {
        return true;
      }
      async _set(key, value) {
        this.storage[key] = value;
      }
      async _get(key) {
        const value = this.storage[key];
        return value === void 0 ? null : value;
      }
      async _remove(key) {
        delete this.storage[key];
      }
      _addListener(_key, _listener) {
        return;
      }
      _removeListener(_key, _listener) {
        return;
      }
    };
    InMemoryPersistence.type = "NONE";
    inMemoryPersistence = InMemoryPersistence;
    PersistenceUserManager = class _PersistenceUserManager {
      constructor(persistence, auth2, userKey) {
        this.persistence = persistence;
        this.auth = auth2;
        this.userKey = userKey;
        const { config, name: name6 } = this.auth;
        this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name6);
        this.fullPersistenceKey = _persistenceKeyName("persistence", config.apiKey, name6);
        this.boundEventHandler = auth2._onStorageEvent.bind(auth2);
        this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
      }
      setCurrentUser(user) {
        return this.persistence._set(this.fullUserKey, user.toJSON());
      }
      async getCurrentUser() {
        const blob = await this.persistence._get(this.fullUserKey);
        if (!blob) {
          return null;
        }
        if (typeof blob === "string") {
          const response = await getAccountInfo(this.auth, { idToken: blob }).catch(() => void 0);
          if (!response) {
            return null;
          }
          return UserImpl._fromGetAccountInfoResponse(this.auth, response, blob);
        }
        return UserImpl._fromJSON(this.auth, blob);
      }
      removeCurrentUser() {
        return this.persistence._remove(this.fullUserKey);
      }
      savePersistenceForRedirect() {
        return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
      }
      async setPersistence(newPersistence) {
        if (this.persistence === newPersistence) {
          return;
        }
        const currentUser = await this.getCurrentUser();
        await this.removeCurrentUser();
        this.persistence = newPersistence;
        if (currentUser) {
          return this.setCurrentUser(currentUser);
        }
      }
      delete() {
        this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
      }
      static async create(auth2, persistenceHierarchy, userKey = "authUser") {
        if (!persistenceHierarchy.length) {
          return new _PersistenceUserManager(_getInstance(inMemoryPersistence), auth2, userKey);
        }
        const availablePersistences = (await Promise.all(persistenceHierarchy.map(async (persistence) => {
          if (await persistence._isAvailable()) {
            return persistence;
          }
          return void 0;
        }))).filter((persistence) => persistence);
        let selectedPersistence = availablePersistences[0] || _getInstance(inMemoryPersistence);
        const key = _persistenceKeyName(userKey, auth2.config.apiKey, auth2.name);
        let userToMigrate = null;
        for (const persistence of persistenceHierarchy) {
          try {
            const blob = await persistence._get(key);
            if (blob) {
              let user;
              if (typeof blob === "string") {
                const response = await getAccountInfo(auth2, {
                  idToken: blob
                }).catch(() => void 0);
                if (!response) {
                  break;
                }
                user = await UserImpl._fromGetAccountInfoResponse(auth2, response, blob);
              } else {
                user = UserImpl._fromJSON(auth2, blob);
              }
              if (persistence !== selectedPersistence) {
                userToMigrate = user;
              }
              selectedPersistence = persistence;
              break;
            }
          } catch {
          }
        }
        const migrationHierarchy = availablePersistences.filter((p) => p._shouldAllowMigration);
        if (!selectedPersistence._shouldAllowMigration || !migrationHierarchy.length) {
          return new _PersistenceUserManager(selectedPersistence, auth2, userKey);
        }
        selectedPersistence = migrationHierarchy[0];
        if (userToMigrate) {
          await selectedPersistence._set(key, userToMigrate.toJSON());
        }
        await Promise.all(persistenceHierarchy.map(async (persistence) => {
          if (persistence !== selectedPersistence) {
            try {
              await persistence._remove(key);
            } catch {
            }
          }
        }));
        return new _PersistenceUserManager(selectedPersistence, auth2, userKey);
      }
    };
    AuthMiddlewareQueue = class {
      constructor(auth2) {
        this.auth = auth2;
        this.queue = [];
      }
      pushCallback(callback, onAbort) {
        const wrappedCallback = (user) => new Promise((resolve, reject) => {
          try {
            const result = callback(user);
            resolve(result);
          } catch (e) {
            reject(e);
          }
        });
        wrappedCallback.onAbort = onAbort;
        this.queue.push(wrappedCallback);
        const index = this.queue.length - 1;
        return () => {
          this.queue[index] = () => Promise.resolve();
        };
      }
      async runMiddleware(nextUser) {
        if (this.auth.currentUser === nextUser) {
          return;
        }
        const onAbortStack = [];
        try {
          for (const beforeStateCallback of this.queue) {
            await beforeStateCallback(nextUser);
            if (beforeStateCallback.onAbort) {
              onAbortStack.push(beforeStateCallback.onAbort);
            }
          }
        } catch (e) {
          onAbortStack.reverse();
          for (const onAbort of onAbortStack) {
            try {
              onAbort();
            } catch (_) {
            }
          }
          throw this.auth._errorFactory.create("login-blocked", {
            originalMessage: e?.message
          });
        }
      }
    };
    MINIMUM_MIN_PASSWORD_LENGTH = 6;
    PasswordPolicyImpl = class {
      constructor(response) {
        const responseOptions = response.customStrengthOptions;
        this.customStrengthOptions = {};
        this.customStrengthOptions.minPasswordLength = responseOptions.minPasswordLength ?? MINIMUM_MIN_PASSWORD_LENGTH;
        if (responseOptions.maxPasswordLength) {
          this.customStrengthOptions.maxPasswordLength = responseOptions.maxPasswordLength;
        }
        if (responseOptions.containsLowercaseCharacter !== void 0) {
          this.customStrengthOptions.containsLowercaseLetter = responseOptions.containsLowercaseCharacter;
        }
        if (responseOptions.containsUppercaseCharacter !== void 0) {
          this.customStrengthOptions.containsUppercaseLetter = responseOptions.containsUppercaseCharacter;
        }
        if (responseOptions.containsNumericCharacter !== void 0) {
          this.customStrengthOptions.containsNumericCharacter = responseOptions.containsNumericCharacter;
        }
        if (responseOptions.containsNonAlphanumericCharacter !== void 0) {
          this.customStrengthOptions.containsNonAlphanumericCharacter = responseOptions.containsNonAlphanumericCharacter;
        }
        this.enforcementState = response.enforcementState;
        if (this.enforcementState === "ENFORCEMENT_STATE_UNSPECIFIED") {
          this.enforcementState = "OFF";
        }
        this.allowedNonAlphanumericCharacters = response.allowedNonAlphanumericCharacters?.join("") ?? "";
        this.forceUpgradeOnSignin = response.forceUpgradeOnSignin ?? false;
        this.schemaVersion = response.schemaVersion;
      }
      validatePassword(password) {
        const status = {
          isValid: true,
          passwordPolicy: this
        };
        this.validatePasswordLengthOptions(password, status);
        this.validatePasswordCharacterOptions(password, status);
        status.isValid && (status.isValid = status.meetsMinPasswordLength ?? true);
        status.isValid && (status.isValid = status.meetsMaxPasswordLength ?? true);
        status.isValid && (status.isValid = status.containsLowercaseLetter ?? true);
        status.isValid && (status.isValid = status.containsUppercaseLetter ?? true);
        status.isValid && (status.isValid = status.containsNumericCharacter ?? true);
        status.isValid && (status.isValid = status.containsNonAlphanumericCharacter ?? true);
        return status;
      }
      /**
       * Validates that the password meets the length options for the policy.
       *
       * @param password Password to validate.
       * @param status Validation status.
       */
      validatePasswordLengthOptions(password, status) {
        const minPasswordLength = this.customStrengthOptions.minPasswordLength;
        const maxPasswordLength = this.customStrengthOptions.maxPasswordLength;
        if (minPasswordLength) {
          status.meetsMinPasswordLength = password.length >= minPasswordLength;
        }
        if (maxPasswordLength) {
          status.meetsMaxPasswordLength = password.length <= maxPasswordLength;
        }
      }
      /**
       * Validates that the password meets the character options for the policy.
       *
       * @param password Password to validate.
       * @param status Validation status.
       */
      validatePasswordCharacterOptions(password, status) {
        this.updatePasswordCharacterOptionsStatuses(
          status,
          /* containsLowercaseCharacter= */
          false,
          /* containsUppercaseCharacter= */
          false,
          /* containsNumericCharacter= */
          false,
          /* containsNonAlphanumericCharacter= */
          false
        );
        let passwordChar;
        for (let i = 0; i < password.length; i++) {
          passwordChar = password.charAt(i);
          this.updatePasswordCharacterOptionsStatuses(
            status,
            /* containsLowercaseCharacter= */
            passwordChar >= "a" && passwordChar <= "z",
            /* containsUppercaseCharacter= */
            passwordChar >= "A" && passwordChar <= "Z",
            /* containsNumericCharacter= */
            passwordChar >= "0" && passwordChar <= "9",
            /* containsNonAlphanumericCharacter= */
            this.allowedNonAlphanumericCharacters.includes(passwordChar)
          );
        }
      }
      /**
       * Updates the running validation status with the statuses for the character options.
       * Expected to be called each time a character is processed to update each option status
       * based on the current character.
       *
       * @param status Validation status.
       * @param containsLowercaseCharacter Whether the character is a lowercase letter.
       * @param containsUppercaseCharacter Whether the character is an uppercase letter.
       * @param containsNumericCharacter Whether the character is a numeric character.
       * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.
       */
      updatePasswordCharacterOptionsStatuses(status, containsLowercaseCharacter, containsUppercaseCharacter, containsNumericCharacter, containsNonAlphanumericCharacter) {
        if (this.customStrengthOptions.containsLowercaseLetter) {
          status.containsLowercaseLetter || (status.containsLowercaseLetter = containsLowercaseCharacter);
        }
        if (this.customStrengthOptions.containsUppercaseLetter) {
          status.containsUppercaseLetter || (status.containsUppercaseLetter = containsUppercaseCharacter);
        }
        if (this.customStrengthOptions.containsNumericCharacter) {
          status.containsNumericCharacter || (status.containsNumericCharacter = containsNumericCharacter);
        }
        if (this.customStrengthOptions.containsNonAlphanumericCharacter) {
          status.containsNonAlphanumericCharacter || (status.containsNonAlphanumericCharacter = containsNonAlphanumericCharacter);
        }
      }
    };
    AuthImpl = class {
      constructor(app2, heartbeatServiceProvider, appCheckServiceProvider, config) {
        this.app = app2;
        this.heartbeatServiceProvider = heartbeatServiceProvider;
        this.appCheckServiceProvider = appCheckServiceProvider;
        this.config = config;
        this.currentUser = null;
        this.emulatorConfig = null;
        this.operations = Promise.resolve();
        this.authStateSubscription = new Subscription(this);
        this.idTokenSubscription = new Subscription(this);
        this.beforeStateQueue = new AuthMiddlewareQueue(this);
        this.redirectUser = null;
        this.isProactiveRefreshEnabled = false;
        this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION = 1;
        this._canInitEmulator = true;
        this._isInitialized = false;
        this._deleted = false;
        this._initializationPromise = null;
        this._popupRedirectResolver = null;
        this._errorFactory = _DEFAULT_AUTH_ERROR_FACTORY;
        this._agentRecaptchaConfig = null;
        this._tenantRecaptchaConfigs = {};
        this._projectPasswordPolicy = null;
        this._tenantPasswordPolicies = {};
        this._resolvePersistenceManagerAvailable = void 0;
        this.lastNotifiedUid = void 0;
        this.languageCode = null;
        this.tenantId = null;
        this.settings = { appVerificationDisabledForTesting: false };
        this.frameworks = [];
        this.name = app2.name;
        this.clientVersion = config.sdkClientVersion;
        this._persistenceManagerAvailable = new Promise((resolve) => this._resolvePersistenceManagerAvailable = resolve);
      }
      _initializeWithPersistence(persistenceHierarchy, popupRedirectResolver) {
        if (popupRedirectResolver) {
          this._popupRedirectResolver = _getInstance(popupRedirectResolver);
        }
        this._initializationPromise = this.queue(async () => {
          if (this._deleted) {
            return;
          }
          this.persistenceManager = await PersistenceUserManager.create(this, persistenceHierarchy);
          this._resolvePersistenceManagerAvailable?.();
          if (this._deleted) {
            return;
          }
          if (this._popupRedirectResolver?._shouldInitProactively) {
            try {
              await this._popupRedirectResolver._initialize(this);
            } catch (e) {
            }
          }
          await this.initializeCurrentUser(popupRedirectResolver);
          this.lastNotifiedUid = this.currentUser?.uid || null;
          if (this._deleted) {
            return;
          }
          this._isInitialized = true;
        });
        return this._initializationPromise;
      }
      /**
       * If the persistence is changed in another window, the user manager will let us know
       */
      async _onStorageEvent() {
        if (this._deleted) {
          return;
        }
        const user = await this.assertedPersistence.getCurrentUser();
        if (!this.currentUser && !user) {
          return;
        }
        if (this.currentUser && user && this.currentUser.uid === user.uid) {
          this._currentUser._assign(user);
          await this.currentUser.getIdToken();
          return;
        }
        await this._updateCurrentUser(
          user,
          /* skipBeforeStateCallbacks */
          true
        );
      }
      async initializeCurrentUserFromIdToken(idToken) {
        try {
          const response = await getAccountInfo(this, { idToken });
          const user = await UserImpl._fromGetAccountInfoResponse(this, response, idToken);
          await this.directlySetCurrentUser(user);
        } catch (err) {
          console.warn("FirebaseServerApp could not login user with provided authIdToken: ", err);
          await this.directlySetCurrentUser(null);
        }
      }
      async initializeCurrentUser(popupRedirectResolver) {
        if (_isFirebaseServerApp(this.app)) {
          const idToken = this.app.settings.authIdToken;
          if (idToken) {
            return new Promise((resolve) => {
              setTimeout(() => this.initializeCurrentUserFromIdToken(idToken).then(resolve, resolve));
            });
          } else {
            return this.directlySetCurrentUser(null);
          }
        }
        const previouslyStoredUser = await this.assertedPersistence.getCurrentUser();
        let futureCurrentUser = previouslyStoredUser;
        let needsTocheckMiddleware = false;
        if (popupRedirectResolver && this.config.authDomain) {
          await this.getOrInitRedirectPersistenceManager();
          const redirectUserEventId = this.redirectUser?._redirectEventId;
          const storedUserEventId = futureCurrentUser?._redirectEventId;
          const result = await this.tryRedirectSignIn(popupRedirectResolver);
          if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) && result?.user) {
            futureCurrentUser = result.user;
            needsTocheckMiddleware = true;
          }
        }
        if (!futureCurrentUser) {
          return this.directlySetCurrentUser(null);
        }
        if (!futureCurrentUser._redirectEventId) {
          if (needsTocheckMiddleware) {
            try {
              await this.beforeStateQueue.runMiddleware(futureCurrentUser);
            } catch (e) {
              futureCurrentUser = previouslyStoredUser;
              this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(e));
            }
          }
          if (futureCurrentUser) {
            return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
          } else {
            return this.directlySetCurrentUser(null);
          }
        }
        _assert(
          this._popupRedirectResolver,
          this,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        await this.getOrInitRedirectPersistenceManager();
        if (this.redirectUser && this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
          return this.directlySetCurrentUser(futureCurrentUser);
        }
        return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
      }
      async tryRedirectSignIn(redirectResolver) {
        let result = null;
        try {
          result = await this._popupRedirectResolver._completeRedirectFn(this, redirectResolver, true);
        } catch (e) {
          await this._setRedirectUser(null);
        }
        return result;
      }
      async reloadAndSetCurrentUserOrClear(user) {
        try {
          await _reloadWithoutSaving(user);
        } catch (e) {
          if (e?.code !== `auth/${"network-request-failed"}`) {
            return this.directlySetCurrentUser(null);
          }
        }
        return this.directlySetCurrentUser(user);
      }
      useDeviceLanguage() {
        this.languageCode = _getUserLanguage();
      }
      async _delete() {
        this._deleted = true;
      }
      async updateCurrentUser(userExtern) {
        if (_isFirebaseServerApp(this.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(this));
        }
        const user = userExtern ? getModularInstance(userExtern) : null;
        if (user) {
          _assert(
            user.auth.config.apiKey === this.config.apiKey,
            this,
            "invalid-user-token"
            /* AuthErrorCode.INVALID_AUTH */
          );
        }
        return this._updateCurrentUser(user && user._clone(this));
      }
      async _updateCurrentUser(user, skipBeforeStateCallbacks = false) {
        if (this._deleted) {
          return;
        }
        if (user) {
          _assert(
            this.tenantId === user.tenantId,
            this,
            "tenant-id-mismatch"
            /* AuthErrorCode.TENANT_ID_MISMATCH */
          );
        }
        if (!skipBeforeStateCallbacks) {
          await this.beforeStateQueue.runMiddleware(user);
        }
        return this.queue(async () => {
          await this.directlySetCurrentUser(user);
          this.notifyAuthListeners();
        });
      }
      async signOut() {
        if (_isFirebaseServerApp(this.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(this));
        }
        await this.beforeStateQueue.runMiddleware(null);
        if (this.redirectPersistenceManager || this._popupRedirectResolver) {
          await this._setRedirectUser(null);
        }
        return this._updateCurrentUser(
          null,
          /* skipBeforeStateCallbacks */
          true
        );
      }
      setPersistence(persistence) {
        if (_isFirebaseServerApp(this.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(this));
        }
        return this.queue(async () => {
          await this.assertedPersistence.setPersistence(_getInstance(persistence));
        });
      }
      _getRecaptchaConfig() {
        if (this.tenantId == null) {
          return this._agentRecaptchaConfig;
        } else {
          return this._tenantRecaptchaConfigs[this.tenantId];
        }
      }
      async validatePassword(password) {
        if (!this._getPasswordPolicyInternal()) {
          await this._updatePasswordPolicy();
        }
        const passwordPolicy = this._getPasswordPolicyInternal();
        if (passwordPolicy.schemaVersion !== this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION) {
          return Promise.reject(this._errorFactory.create("unsupported-password-policy-schema-version", {}));
        }
        return passwordPolicy.validatePassword(password);
      }
      _getPasswordPolicyInternal() {
        if (this.tenantId === null) {
          return this._projectPasswordPolicy;
        } else {
          return this._tenantPasswordPolicies[this.tenantId];
        }
      }
      async _updatePasswordPolicy() {
        const response = await _getPasswordPolicy(this);
        const passwordPolicy = new PasswordPolicyImpl(response);
        if (this.tenantId === null) {
          this._projectPasswordPolicy = passwordPolicy;
        } else {
          this._tenantPasswordPolicies[this.tenantId] = passwordPolicy;
        }
      }
      _getPersistenceType() {
        return this.assertedPersistence.persistence.type;
      }
      _getPersistence() {
        return this.assertedPersistence.persistence;
      }
      _updateErrorMap(errorMap) {
        this._errorFactory = new ErrorFactory("auth", "Firebase", errorMap());
      }
      onAuthStateChanged(nextOrObserver, error, completed) {
        return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
      }
      beforeAuthStateChanged(callback, onAbort) {
        return this.beforeStateQueue.pushCallback(callback, onAbort);
      }
      onIdTokenChanged(nextOrObserver, error, completed) {
        return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
      }
      authStateReady() {
        return new Promise((resolve, reject) => {
          if (this.currentUser) {
            resolve();
          } else {
            const unsubscribe = this.onAuthStateChanged(() => {
              unsubscribe();
              resolve();
            }, reject);
          }
        });
      }
      /**
       * Revokes the given access token. Currently only supports Apple OAuth access tokens.
       */
      async revokeAccessToken(token) {
        if (this.currentUser) {
          const idToken = await this.currentUser.getIdToken();
          const request = {
            providerId: "apple.com",
            tokenType: "ACCESS_TOKEN",
            token,
            idToken
          };
          if (this.tenantId != null) {
            request.tenantId = this.tenantId;
          }
          await revokeToken(this, request);
        }
      }
      toJSON() {
        return {
          apiKey: this.config.apiKey,
          authDomain: this.config.authDomain,
          appName: this.name,
          currentUser: this._currentUser?.toJSON()
        };
      }
      async _setRedirectUser(user, popupRedirectResolver) {
        const redirectManager = await this.getOrInitRedirectPersistenceManager(popupRedirectResolver);
        return user === null ? redirectManager.removeCurrentUser() : redirectManager.setCurrentUser(user);
      }
      async getOrInitRedirectPersistenceManager(popupRedirectResolver) {
        if (!this.redirectPersistenceManager) {
          const resolver = popupRedirectResolver && _getInstance(popupRedirectResolver) || this._popupRedirectResolver;
          _assert(
            resolver,
            this,
            "argument-error"
            /* AuthErrorCode.ARGUMENT_ERROR */
          );
          this.redirectPersistenceManager = await PersistenceUserManager.create(
            this,
            [_getInstance(resolver._redirectPersistence)],
            "redirectUser"
            /* KeyName.REDIRECT_USER */
          );
          this.redirectUser = await this.redirectPersistenceManager.getCurrentUser();
        }
        return this.redirectPersistenceManager;
      }
      async _redirectUserForId(id) {
        if (this._isInitialized) {
          await this.queue(async () => {
          });
        }
        if (this._currentUser?._redirectEventId === id) {
          return this._currentUser;
        }
        if (this.redirectUser?._redirectEventId === id) {
          return this.redirectUser;
        }
        return null;
      }
      async _persistUserIfCurrent(user) {
        if (user === this.currentUser) {
          return this.queue(async () => this.directlySetCurrentUser(user));
        }
      }
      /** Notifies listeners only if the user is current */
      _notifyListenersIfCurrent(user) {
        if (user === this.currentUser) {
          this.notifyAuthListeners();
        }
      }
      _key() {
        return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;
      }
      _startProactiveRefresh() {
        this.isProactiveRefreshEnabled = true;
        if (this.currentUser) {
          this._currentUser._startProactiveRefresh();
        }
      }
      _stopProactiveRefresh() {
        this.isProactiveRefreshEnabled = false;
        if (this.currentUser) {
          this._currentUser._stopProactiveRefresh();
        }
      }
      /** Returns the current user cast as the internal type */
      get _currentUser() {
        return this.currentUser;
      }
      notifyAuthListeners() {
        if (!this._isInitialized) {
          return;
        }
        this.idTokenSubscription.next(this.currentUser);
        const currentUid = this.currentUser?.uid ?? null;
        if (this.lastNotifiedUid !== currentUid) {
          this.lastNotifiedUid = currentUid;
          this.authStateSubscription.next(this.currentUser);
        }
      }
      registerStateListener(subscription, nextOrObserver, error, completed) {
        if (this._deleted) {
          return () => {
          };
        }
        const cb = typeof nextOrObserver === "function" ? nextOrObserver : nextOrObserver.next.bind(nextOrObserver);
        let isUnsubscribed = false;
        const promise = this._isInitialized ? Promise.resolve() : this._initializationPromise;
        _assert(
          promise,
          this,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        promise.then(() => {
          if (isUnsubscribed) {
            return;
          }
          cb(this.currentUser);
        });
        if (typeof nextOrObserver === "function") {
          const unsubscribe = subscription.addObserver(nextOrObserver, error, completed);
          return () => {
            isUnsubscribed = true;
            unsubscribe();
          };
        } else {
          const unsubscribe = subscription.addObserver(nextOrObserver);
          return () => {
            isUnsubscribed = true;
            unsubscribe();
          };
        }
      }
      /**
       * Unprotected (from race conditions) method to set the current user. This
       * should only be called from within a queued callback. This is necessary
       * because the queue shouldn't rely on another queued callback.
       */
      async directlySetCurrentUser(user) {
        if (this.currentUser && this.currentUser !== user) {
          this._currentUser._stopProactiveRefresh();
        }
        if (user && this.isProactiveRefreshEnabled) {
          user._startProactiveRefresh();
        }
        this.currentUser = user;
        if (user) {
          await this.assertedPersistence.setCurrentUser(user);
        } else {
          await this.assertedPersistence.removeCurrentUser();
        }
      }
      queue(action) {
        this.operations = this.operations.then(action, action);
        return this.operations;
      }
      get assertedPersistence() {
        _assert(
          this.persistenceManager,
          this,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        return this.persistenceManager;
      }
      _logFramework(framework) {
        if (!framework || this.frameworks.includes(framework)) {
          return;
        }
        this.frameworks.push(framework);
        this.frameworks.sort();
        this.clientVersion = _getClientVersion(this.config.clientPlatform, this._getFrameworks());
      }
      _getFrameworks() {
        return this.frameworks;
      }
      async _getAdditionalHeaders() {
        const headers = {
          [
            "X-Client-Version"
            /* HttpHeader.X_CLIENT_VERSION */
          ]: this.clientVersion
        };
        if (this.app.options.appId) {
          headers[
            "X-Firebase-gmpid"
            /* HttpHeader.X_FIREBASE_GMPID */
          ] = this.app.options.appId;
        }
        const heartbeatsHeader = await this.heartbeatServiceProvider.getImmediate({
          optional: true
        })?.getHeartbeatsHeader();
        if (heartbeatsHeader) {
          headers[
            "X-Firebase-Client"
            /* HttpHeader.X_FIREBASE_CLIENT */
          ] = heartbeatsHeader;
        }
        const appCheckToken = await this._getAppCheckToken();
        if (appCheckToken) {
          headers[
            "X-Firebase-AppCheck"
            /* HttpHeader.X_FIREBASE_APP_CHECK */
          ] = appCheckToken;
        }
        return headers;
      }
      async _getAppCheckToken() {
        if (_isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {
          return this.app.settings.appCheckToken;
        }
        const appCheckTokenResult = await this.appCheckServiceProvider.getImmediate({ optional: true })?.getToken();
        if (appCheckTokenResult?.error) {
          _logWarn(`Error while retrieving App Check token: ${appCheckTokenResult.error}`);
        }
        return appCheckTokenResult?.token;
      }
    };
    Subscription = class {
      constructor(auth2) {
        this.auth = auth2;
        this.observer = null;
        this.addObserver = createSubscribe((observer) => this.observer = observer);
      }
      get next() {
        _assert(
          this.observer,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        return this.observer.next.bind(this.observer);
      }
    };
    externalJSProvider = {
      async loadJS() {
        throw new Error("Unable to load external scripts");
      },
      recaptchaV2Script: "",
      recaptchaEnterpriseScript: "",
      gapiScript: ""
    };
    MockGreCAPTCHATopLevel = class {
      constructor() {
        this.enterprise = new MockGreCAPTCHA();
      }
      ready(callback) {
        callback();
      }
      execute(_siteKey, _options) {
        return Promise.resolve("token");
      }
      render(_container, _parameters) {
        return "";
      }
    };
    MockGreCAPTCHA = class {
      ready(callback) {
        callback();
      }
      execute(_siteKey, _options) {
        return Promise.resolve("token");
      }
      render(_container, _parameters) {
        return "";
      }
    };
    RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = "recaptcha-enterprise";
    FAKE_TOKEN = "NO_RECAPTCHA";
    RecaptchaEnterpriseVerifier = class {
      /**
       *
       * @param authExtern - The corresponding Firebase {@link Auth} instance.
       *
       */
      constructor(authExtern) {
        this.type = RECAPTCHA_ENTERPRISE_VERIFIER_TYPE;
        this.auth = _castAuth(authExtern);
      }
      /**
       * Executes the verification process.
       *
       * @returns A Promise for a token that can be used to assert the validity of a request.
       */
      async verify(action = "verify", forceRefresh = false) {
        async function retrieveSiteKey(auth2) {
          if (!forceRefresh) {
            if (auth2.tenantId == null && auth2._agentRecaptchaConfig != null) {
              return auth2._agentRecaptchaConfig.siteKey;
            }
            if (auth2.tenantId != null && auth2._tenantRecaptchaConfigs[auth2.tenantId] !== void 0) {
              return auth2._tenantRecaptchaConfigs[auth2.tenantId].siteKey;
            }
          }
          return new Promise(async (resolve, reject) => {
            getRecaptchaConfig(auth2, {
              clientType: "CLIENT_TYPE_WEB",
              version: "RECAPTCHA_ENTERPRISE"
              /* RecaptchaVersion.ENTERPRISE */
            }).then((response) => {
              if (response.recaptchaKey === void 0) {
                reject(new Error("recaptcha Enterprise site key undefined"));
              } else {
                const config = new RecaptchaConfig(response);
                if (auth2.tenantId == null) {
                  auth2._agentRecaptchaConfig = config;
                } else {
                  auth2._tenantRecaptchaConfigs[auth2.tenantId] = config;
                }
                return resolve(config.siteKey);
              }
            }).catch((error) => {
              reject(error);
            });
          });
        }
        function retrieveRecaptchaToken(siteKey, resolve, reject) {
          const grecaptcha = window.grecaptcha;
          if (isEnterprise(grecaptcha)) {
            grecaptcha.enterprise.ready(() => {
              grecaptcha.enterprise.execute(siteKey, { action }).then((token) => {
                resolve(token);
              }).catch(() => {
                resolve(FAKE_TOKEN);
              });
            });
          } else {
            reject(Error("No reCAPTCHA enterprise script loaded."));
          }
        }
        if (this.auth.settings.appVerificationDisabledForTesting) {
          const mockRecaptcha = new MockGreCAPTCHATopLevel();
          return mockRecaptcha.execute("siteKey", { action: "verify" });
        }
        return new Promise((resolve, reject) => {
          retrieveSiteKey(this.auth).then((siteKey) => {
            if (!forceRefresh && isEnterprise(window.grecaptcha)) {
              retrieveRecaptchaToken(siteKey, resolve, reject);
            } else {
              if (typeof window === "undefined") {
                reject(new Error("RecaptchaVerifier is only supported in browser"));
                return;
              }
              let url = _recaptchaEnterpriseScriptUrl();
              if (url.length !== 0) {
                url += siteKey;
              }
              _loadJS(url).then(() => {
                retrieveRecaptchaToken(siteKey, resolve, reject);
              }).catch((error) => {
                reject(error);
              });
            }
          }).catch((error) => {
            reject(error);
          });
        });
      }
    };
    AuthCredential = class {
      /** @internal */
      constructor(providerId, signInMethod) {
        this.providerId = providerId;
        this.signInMethod = signInMethod;
      }
      /**
       * Returns a JSON-serializable representation of this object.
       *
       * @returns a JSON-serializable representation of this object.
       */
      toJSON() {
        return debugFail("not implemented");
      }
      /** @internal */
      _getIdTokenResponse(_auth) {
        return debugFail("not implemented");
      }
      /** @internal */
      _linkToIdToken(_auth, _idToken) {
        return debugFail("not implemented");
      }
      /** @internal */
      _getReauthenticationResolver(_auth) {
        return debugFail("not implemented");
      }
    };
    EmailAuthCredential = class _EmailAuthCredential extends AuthCredential {
      /** @internal */
      constructor(_email, _password, signInMethod, _tenantId = null) {
        super("password", signInMethod);
        this._email = _email;
        this._password = _password;
        this._tenantId = _tenantId;
      }
      /** @internal */
      static _fromEmailAndPassword(email, password) {
        return new _EmailAuthCredential(
          email,
          password,
          "password"
          /* SignInMethod.EMAIL_PASSWORD */
        );
      }
      /** @internal */
      static _fromEmailAndCode(email, oobCode, tenantId = null) {
        return new _EmailAuthCredential(email, oobCode, "emailLink", tenantId);
      }
      /** {@inheritdoc AuthCredential.toJSON} */
      toJSON() {
        return {
          email: this._email,
          password: this._password,
          signInMethod: this.signInMethod,
          tenantId: this._tenantId
        };
      }
      /**
       * Static method to deserialize a JSON representation of an object into an {@link  AuthCredential}.
       *
       * @param json - Either `object` or the stringified representation of the object. When string is
       * provided, `JSON.parse` would be called first.
       *
       * @returns If the JSON input does not represent an {@link AuthCredential}, null is returned.
       */
      static fromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        if (obj?.email && obj?.password) {
          if (obj.signInMethod === "password") {
            return this._fromEmailAndPassword(obj.email, obj.password);
          } else if (obj.signInMethod === "emailLink") {
            return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);
          }
        }
        return null;
      }
      /** @internal */
      async _getIdTokenResponse(auth2) {
        switch (this.signInMethod) {
          case "password":
            const request = {
              returnSecureToken: true,
              email: this._email,
              password: this._password,
              clientType: "CLIENT_TYPE_WEB"
              /* RecaptchaClientType.WEB */
            };
            return handleRecaptchaFlow(
              auth2,
              request,
              "signInWithPassword",
              signInWithPassword,
              "EMAIL_PASSWORD_PROVIDER"
              /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
            );
          case "emailLink":
            return signInWithEmailLink$1(auth2, {
              email: this._email,
              oobCode: this._password
            });
          default:
            _fail(
              auth2,
              "internal-error"
              /* AuthErrorCode.INTERNAL_ERROR */
            );
        }
      }
      /** @internal */
      async _linkToIdToken(auth2, idToken) {
        switch (this.signInMethod) {
          case "password":
            const request = {
              idToken,
              returnSecureToken: true,
              email: this._email,
              password: this._password,
              clientType: "CLIENT_TYPE_WEB"
              /* RecaptchaClientType.WEB */
            };
            return handleRecaptchaFlow(
              auth2,
              request,
              "signUpPassword",
              linkEmailPassword,
              "EMAIL_PASSWORD_PROVIDER"
              /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
            );
          case "emailLink":
            return signInWithEmailLinkForLinking(auth2, {
              idToken,
              email: this._email,
              oobCode: this._password
            });
          default:
            _fail(
              auth2,
              "internal-error"
              /* AuthErrorCode.INTERNAL_ERROR */
            );
        }
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        return this._getIdTokenResponse(auth2);
      }
    };
    IDP_REQUEST_URI$1 = "http://localhost";
    OAuthCredential = class _OAuthCredential extends AuthCredential {
      constructor() {
        super(...arguments);
        this.pendingToken = null;
      }
      /** @internal */
      static _fromParams(params) {
        const cred = new _OAuthCredential(params.providerId, params.signInMethod);
        if (params.idToken || params.accessToken) {
          if (params.idToken) {
            cred.idToken = params.idToken;
          }
          if (params.accessToken) {
            cred.accessToken = params.accessToken;
          }
          if (params.nonce && !params.pendingToken) {
            cred.nonce = params.nonce;
          }
          if (params.pendingToken) {
            cred.pendingToken = params.pendingToken;
          }
        } else if (params.oauthToken && params.oauthTokenSecret) {
          cred.accessToken = params.oauthToken;
          cred.secret = params.oauthTokenSecret;
        } else {
          _fail(
            "argument-error"
            /* AuthErrorCode.ARGUMENT_ERROR */
          );
        }
        return cred;
      }
      /** {@inheritdoc AuthCredential.toJSON}  */
      toJSON() {
        return {
          idToken: this.idToken,
          accessToken: this.accessToken,
          secret: this.secret,
          nonce: this.nonce,
          pendingToken: this.pendingToken,
          providerId: this.providerId,
          signInMethod: this.signInMethod
        };
      }
      /**
       * Static method to deserialize a JSON representation of an object into an
       * {@link  AuthCredential}.
       *
       * @param json - Input can be either Object or the stringified representation of the object.
       * When string is provided, JSON.parse would be called first.
       *
       * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
       */
      static fromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        const { providerId, signInMethod, ...rest } = obj;
        if (!providerId || !signInMethod) {
          return null;
        }
        const cred = new _OAuthCredential(providerId, signInMethod);
        cred.idToken = rest.idToken || void 0;
        cred.accessToken = rest.accessToken || void 0;
        cred.secret = rest.secret;
        cred.nonce = rest.nonce;
        cred.pendingToken = rest.pendingToken || null;
        return cred;
      }
      /** @internal */
      _getIdTokenResponse(auth2) {
        const request = this.buildRequest();
        return signInWithIdp(auth2, request);
      }
      /** @internal */
      _linkToIdToken(auth2, idToken) {
        const request = this.buildRequest();
        request.idToken = idToken;
        return signInWithIdp(auth2, request);
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        const request = this.buildRequest();
        request.autoCreate = false;
        return signInWithIdp(auth2, request);
      }
      buildRequest() {
        const request = {
          requestUri: IDP_REQUEST_URI$1,
          returnSecureToken: true
        };
        if (this.pendingToken) {
          request.pendingToken = this.pendingToken;
        } else {
          const postBody = {};
          if (this.idToken) {
            postBody["id_token"] = this.idToken;
          }
          if (this.accessToken) {
            postBody["access_token"] = this.accessToken;
          }
          if (this.secret) {
            postBody["oauth_token_secret"] = this.secret;
          }
          postBody["providerId"] = this.providerId;
          if (this.nonce && !this.pendingToken) {
            postBody["nonce"] = this.nonce;
          }
          request.postBody = querystring(postBody);
        }
        return request;
      }
    };
    VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_ = {
      [
        "USER_NOT_FOUND"
        /* ServerError.USER_NOT_FOUND */
      ]: "user-not-found"
      /* AuthErrorCode.USER_DELETED */
    };
    PhoneAuthCredential = class _PhoneAuthCredential extends AuthCredential {
      constructor(params) {
        super(
          "phone",
          "phone"
          /* SignInMethod.PHONE */
        );
        this.params = params;
      }
      /** @internal */
      static _fromVerification(verificationId, verificationCode) {
        return new _PhoneAuthCredential({ verificationId, verificationCode });
      }
      /** @internal */
      static _fromTokenResponse(phoneNumber, temporaryProof) {
        return new _PhoneAuthCredential({ phoneNumber, temporaryProof });
      }
      /** @internal */
      _getIdTokenResponse(auth2) {
        return signInWithPhoneNumber$1(auth2, this._makeVerificationRequest());
      }
      /** @internal */
      _linkToIdToken(auth2, idToken) {
        return linkWithPhoneNumber$1(auth2, {
          idToken,
          ...this._makeVerificationRequest()
        });
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        return verifyPhoneNumberForExisting(auth2, this._makeVerificationRequest());
      }
      /** @internal */
      _makeVerificationRequest() {
        const { temporaryProof, phoneNumber, verificationId, verificationCode } = this.params;
        if (temporaryProof && phoneNumber) {
          return { temporaryProof, phoneNumber };
        }
        return {
          sessionInfo: verificationId,
          code: verificationCode
        };
      }
      /** {@inheritdoc AuthCredential.toJSON} */
      toJSON() {
        const obj = {
          providerId: this.providerId
        };
        if (this.params.phoneNumber) {
          obj.phoneNumber = this.params.phoneNumber;
        }
        if (this.params.temporaryProof) {
          obj.temporaryProof = this.params.temporaryProof;
        }
        if (this.params.verificationCode) {
          obj.verificationCode = this.params.verificationCode;
        }
        if (this.params.verificationId) {
          obj.verificationId = this.params.verificationId;
        }
        return obj;
      }
      /** Generates a phone credential based on a plain object or a JSON string. */
      static fromJSON(json) {
        if (typeof json === "string") {
          json = JSON.parse(json);
        }
        const { verificationId, verificationCode, phoneNumber, temporaryProof } = json;
        if (!verificationCode && !verificationId && !phoneNumber && !temporaryProof) {
          return null;
        }
        return new _PhoneAuthCredential({
          verificationId,
          verificationCode,
          phoneNumber,
          temporaryProof
        });
      }
    };
    ActionCodeURL = class _ActionCodeURL {
      /**
       * @param actionLink - The link from which to extract the URL.
       * @returns The {@link ActionCodeURL} object, or null if the link is invalid.
       *
       * @internal
       */
      constructor(actionLink) {
        const searchParams = querystringDecode(extractQuerystring(actionLink));
        const apiKey = searchParams[
          "apiKey"
          /* QueryField.API_KEY */
        ] ?? null;
        const code = searchParams[
          "oobCode"
          /* QueryField.CODE */
        ] ?? null;
        const operation = parseMode(searchParams[
          "mode"
          /* QueryField.MODE */
        ] ?? null);
        _assert(
          apiKey && code && operation,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        this.apiKey = apiKey;
        this.operation = operation;
        this.code = code;
        this.continueUrl = searchParams[
          "continueUrl"
          /* QueryField.CONTINUE_URL */
        ] ?? null;
        this.languageCode = searchParams[
          "lang"
          /* QueryField.LANGUAGE_CODE */
        ] ?? null;
        this.tenantId = searchParams[
          "tenantId"
          /* QueryField.TENANT_ID */
        ] ?? null;
      }
      /**
       * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,
       * otherwise returns null.
       *
       * @param link  - The email action link string.
       * @returns The {@link ActionCodeURL} object, or null if the link is invalid.
       *
       * @public
       */
      static parseLink(link) {
        const actionLink = parseDeepLink(link);
        try {
          return new _ActionCodeURL(actionLink);
        } catch {
          return null;
        }
      }
    };
    EmailAuthProvider = class _EmailAuthProvider {
      constructor() {
        this.providerId = _EmailAuthProvider.PROVIDER_ID;
      }
      /**
       * Initialize an {@link AuthCredential} using an email and password.
       *
       * @example
       * ```javascript
       * const authCredential = EmailAuthProvider.credential(email, password);
       * const userCredential = await signInWithCredential(auth, authCredential);
       * ```
       *
       * @example
       * ```javascript
       * const userCredential = await signInWithEmailAndPassword(auth, email, password);
       * ```
       *
       * @param email - Email address.
       * @param password - User account password.
       * @returns The auth provider credential.
       */
      static credential(email, password) {
        return EmailAuthCredential._fromEmailAndPassword(email, password);
      }
      /**
       * Initialize an {@link AuthCredential} using an email and an email link after a sign in with
       * email link operation.
       *
       * @example
       * ```javascript
       * const authCredential = EmailAuthProvider.credentialWithLink(auth, email, emailLink);
       * const userCredential = await signInWithCredential(auth, authCredential);
       * ```
       *
       * @example
       * ```javascript
       * await sendSignInLinkToEmail(auth, email);
       * // Obtain emailLink from user.
       * const userCredential = await signInWithEmailLink(auth, email, emailLink);
       * ```
       *
       * @param auth - The {@link Auth} instance used to verify the link.
       * @param email - Email address.
       * @param emailLink - Sign-in email link.
       * @returns - The auth provider credential.
       */
      static credentialWithLink(email, emailLink) {
        const actionCodeUrl = ActionCodeURL.parseLink(emailLink);
        _assert(
          actionCodeUrl,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return EmailAuthCredential._fromEmailAndCode(email, actionCodeUrl.code, actionCodeUrl.tenantId);
      }
    };
    EmailAuthProvider.PROVIDER_ID = "password";
    EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD = "password";
    EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD = "emailLink";
    FederatedAuthProvider = class {
      /**
       * Constructor for generic OAuth providers.
       *
       * @param providerId - Provider for which credentials should be generated.
       */
      constructor(providerId) {
        this.providerId = providerId;
        this.defaultLanguageCode = null;
        this.customParameters = {};
      }
      /**
       * Set the language gode.
       *
       * @param languageCode - language code
       */
      setDefaultLanguage(languageCode) {
        this.defaultLanguageCode = languageCode;
      }
      /**
       * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in
       * operations.
       *
       * @remarks
       * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,
       * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.
       *
       * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.
       */
      setCustomParameters(customOAuthParameters) {
        this.customParameters = customOAuthParameters;
        return this;
      }
      /**
       * Retrieve the current list of {@link CustomParameters}.
       */
      getCustomParameters() {
        return this.customParameters;
      }
    };
    BaseOAuthProvider = class extends FederatedAuthProvider {
      constructor() {
        super(...arguments);
        this.scopes = [];
      }
      /**
       * Add an OAuth scope to the credential.
       *
       * @param scope - Provider OAuth scope to add.
       */
      addScope(scope) {
        if (!this.scopes.includes(scope)) {
          this.scopes.push(scope);
        }
        return this;
      }
      /**
       * Retrieve the current list of OAuth scopes.
       */
      getScopes() {
        return [...this.scopes];
      }
    };
    OAuthProvider = class _OAuthProvider extends BaseOAuthProvider {
      /**
       * Creates an {@link OAuthCredential} from a JSON string or a plain object.
       * @param json - A plain object or a JSON string
       */
      static credentialFromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        _assert(
          "providerId" in obj && "signInMethod" in obj,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return OAuthCredential._fromParams(obj);
      }
      /**
       * Creates a {@link OAuthCredential} from a generic OAuth provider's access token or ID token.
       *
       * @remarks
       * The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of
       * the raw nonce must match the nonce field in the ID token.
       *
       * @example
       * ```javascript
       * // `googleUser` from the onsuccess Google Sign In callback.
       * // Initialize a generate OAuth provider with a `google.com` providerId.
       * const provider = new OAuthProvider('google.com');
       * const credential = provider.credential({
       *   idToken: googleUser.getAuthResponse().id_token,
       * });
       * const result = await signInWithCredential(credential);
       * ```
       *
       * @param params - Either the options object containing the ID token, access token and raw nonce
       * or the ID token string.
       */
      credential(params) {
        return this._credential({ ...params, nonce: params.rawNonce });
      }
      /** An internal credential method that accepts more permissive options */
      _credential(params) {
        _assert(
          params.idToken || params.accessToken,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return OAuthCredential._fromParams({
          ...params,
          providerId: this.providerId,
          signInMethod: this.providerId
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _OAuthProvider.oauthCredentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _OAuthProvider.oauthCredentialFromTaggedObject(error.customData || {});
      }
      static oauthCredentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { oauthIdToken, oauthAccessToken, oauthTokenSecret, pendingToken, nonce, providerId } = tokenResponse;
        if (!oauthAccessToken && !oauthTokenSecret && !oauthIdToken && !pendingToken) {
          return null;
        }
        if (!providerId) {
          return null;
        }
        try {
          return new _OAuthProvider(providerId)._credential({
            idToken: oauthIdToken,
            accessToken: oauthAccessToken,
            nonce,
            pendingToken
          });
        } catch (e) {
          return null;
        }
      }
    };
    FacebookAuthProvider = class _FacebookAuthProvider extends BaseOAuthProvider {
      constructor() {
        super(
          "facebook.com"
          /* ProviderId.FACEBOOK */
        );
      }
      /**
       * Creates a credential for Facebook.
       *
       * @example
       * ```javascript
       * // `event` from the Facebook auth.authResponseChange callback.
       * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);
       * const result = await signInWithCredential(credential);
       * ```
       *
       * @param accessToken - Facebook access token.
       */
      static credential(accessToken) {
        return OAuthCredential._fromParams({
          providerId: _FacebookAuthProvider.PROVIDER_ID,
          signInMethod: _FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,
          accessToken
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _FacebookAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _FacebookAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
          return null;
        }
        if (!tokenResponse.oauthAccessToken) {
          return null;
        }
        try {
          return _FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);
        } catch {
          return null;
        }
      }
    };
    FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD = "facebook.com";
    FacebookAuthProvider.PROVIDER_ID = "facebook.com";
    GoogleAuthProvider = class _GoogleAuthProvider extends BaseOAuthProvider {
      constructor() {
        super(
          "google.com"
          /* ProviderId.GOOGLE */
        );
        this.addScope("profile");
      }
      /**
       * Creates a credential for Google. At least one of ID token and access token is required.
       *
       * @example
       * ```javascript
       * // \`googleUser\` from the onsuccess Google Sign In callback.
       * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);
       * const result = await signInWithCredential(credential);
       * ```
       *
       * @param idToken - Google ID token.
       * @param accessToken - Google access token.
       */
      static credential(idToken, accessToken) {
        return OAuthCredential._fromParams({
          providerId: _GoogleAuthProvider.PROVIDER_ID,
          signInMethod: _GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,
          idToken,
          accessToken
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _GoogleAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _GoogleAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { oauthIdToken, oauthAccessToken } = tokenResponse;
        if (!oauthIdToken && !oauthAccessToken) {
          return null;
        }
        try {
          return _GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);
        } catch {
          return null;
        }
      }
    };
    GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD = "google.com";
    GoogleAuthProvider.PROVIDER_ID = "google.com";
    GithubAuthProvider = class _GithubAuthProvider extends BaseOAuthProvider {
      constructor() {
        super(
          "github.com"
          /* ProviderId.GITHUB */
        );
      }
      /**
       * Creates a credential for GitHub.
       *
       * @param accessToken - GitHub access token.
       */
      static credential(accessToken) {
        return OAuthCredential._fromParams({
          providerId: _GithubAuthProvider.PROVIDER_ID,
          signInMethod: _GithubAuthProvider.GITHUB_SIGN_IN_METHOD,
          accessToken
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _GithubAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _GithubAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
          return null;
        }
        if (!tokenResponse.oauthAccessToken) {
          return null;
        }
        try {
          return _GithubAuthProvider.credential(tokenResponse.oauthAccessToken);
        } catch {
          return null;
        }
      }
    };
    GithubAuthProvider.GITHUB_SIGN_IN_METHOD = "github.com";
    GithubAuthProvider.PROVIDER_ID = "github.com";
    IDP_REQUEST_URI = "http://localhost";
    SAMLAuthCredential = class _SAMLAuthCredential extends AuthCredential {
      /** @internal */
      constructor(providerId, pendingToken) {
        super(providerId, providerId);
        this.pendingToken = pendingToken;
      }
      /** @internal */
      _getIdTokenResponse(auth2) {
        const request = this.buildRequest();
        return signInWithIdp(auth2, request);
      }
      /** @internal */
      _linkToIdToken(auth2, idToken) {
        const request = this.buildRequest();
        request.idToken = idToken;
        return signInWithIdp(auth2, request);
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        const request = this.buildRequest();
        request.autoCreate = false;
        return signInWithIdp(auth2, request);
      }
      /** {@inheritdoc AuthCredential.toJSON}  */
      toJSON() {
        return {
          signInMethod: this.signInMethod,
          providerId: this.providerId,
          pendingToken: this.pendingToken
        };
      }
      /**
       * Static method to deserialize a JSON representation of an object into an
       * {@link  AuthCredential}.
       *
       * @param json - Input can be either Object or the stringified representation of the object.
       * When string is provided, JSON.parse would be called first.
       *
       * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
       */
      static fromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        const { providerId, signInMethod, pendingToken } = obj;
        if (!providerId || !signInMethod || !pendingToken || providerId !== signInMethod) {
          return null;
        }
        return new _SAMLAuthCredential(providerId, pendingToken);
      }
      /**
       * Helper static method to avoid exposing the constructor to end users.
       *
       * @internal
       */
      static _create(providerId, pendingToken) {
        return new _SAMLAuthCredential(providerId, pendingToken);
      }
      buildRequest() {
        return {
          requestUri: IDP_REQUEST_URI,
          returnSecureToken: true,
          pendingToken: this.pendingToken
        };
      }
    };
    SAML_PROVIDER_PREFIX = "saml.";
    SAMLAuthProvider = class _SAMLAuthProvider extends FederatedAuthProvider {
      /**
       * Constructor. The providerId must start with "saml."
       * @param providerId - SAML provider ID.
       */
      constructor(providerId) {
        _assert(
          providerId.startsWith(SAML_PROVIDER_PREFIX),
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        super(providerId);
      }
      /**
       * Generates an {@link AuthCredential} from a {@link UserCredential} after a
       * successful SAML flow completes.
       *
       * @remarks
       *
       * For example, to get an {@link AuthCredential}, you could write the
       * following code:
       *
       * ```js
       * const userCredential = await signInWithPopup(auth, samlProvider);
       * const credential = SAMLAuthProvider.credentialFromResult(userCredential);
       * ```
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _SAMLAuthProvider.samlCredentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _SAMLAuthProvider.samlCredentialFromTaggedObject(error.customData || {});
      }
      /**
       * Creates an {@link AuthCredential} from a JSON string or a plain object.
       * @param json - A plain object or a JSON string
       */
      static credentialFromJSON(json) {
        const credential = SAMLAuthCredential.fromJSON(json);
        _assert(
          credential,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return credential;
      }
      static samlCredentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { pendingToken, providerId } = tokenResponse;
        if (!pendingToken || !providerId) {
          return null;
        }
        try {
          return SAMLAuthCredential._create(providerId, pendingToken);
        } catch (e) {
          return null;
        }
      }
    };
    TwitterAuthProvider = class _TwitterAuthProvider extends BaseOAuthProvider {
      constructor() {
        super(
          "twitter.com"
          /* ProviderId.TWITTER */
        );
      }
      /**
       * Creates a credential for Twitter.
       *
       * @param token - Twitter access token.
       * @param secret - Twitter secret.
       */
      static credential(token, secret) {
        return OAuthCredential._fromParams({
          providerId: _TwitterAuthProvider.PROVIDER_ID,
          signInMethod: _TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,
          oauthToken: token,
          oauthTokenSecret: secret
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _TwitterAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _TwitterAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { oauthAccessToken, oauthTokenSecret } = tokenResponse;
        if (!oauthAccessToken || !oauthTokenSecret) {
          return null;
        }
        try {
          return _TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);
        } catch {
          return null;
        }
      }
    };
    TwitterAuthProvider.TWITTER_SIGN_IN_METHOD = "twitter.com";
    TwitterAuthProvider.PROVIDER_ID = "twitter.com";
    UserCredentialImpl = class _UserCredentialImpl {
      constructor(params) {
        this.user = params.user;
        this.providerId = params.providerId;
        this._tokenResponse = params._tokenResponse;
        this.operationType = params.operationType;
      }
      static async _fromIdTokenResponse(auth2, operationType, idTokenResponse, isAnonymous = false) {
        const user = await UserImpl._fromIdTokenResponse(auth2, idTokenResponse, isAnonymous);
        const providerId = providerIdForResponse(idTokenResponse);
        const userCred = new _UserCredentialImpl({
          user,
          providerId,
          _tokenResponse: idTokenResponse,
          operationType
        });
        return userCred;
      }
      static async _forOperation(user, operationType, response) {
        await user._updateTokensIfNecessary(
          response,
          /* reload */
          true
        );
        const providerId = providerIdForResponse(response);
        return new _UserCredentialImpl({
          user,
          providerId,
          _tokenResponse: response,
          operationType
        });
      }
    };
    MultiFactorError = class _MultiFactorError extends FirebaseError {
      constructor(auth2, error, operationType, user) {
        super(error.code, error.message);
        this.operationType = operationType;
        this.user = user;
        Object.setPrototypeOf(this, _MultiFactorError.prototype);
        this.customData = {
          appName: auth2.name,
          tenantId: auth2.tenantId ?? void 0,
          _serverResponse: error.customData._serverResponse,
          operationType
        };
      }
      static _fromErrorAndOperation(auth2, error, operationType, user) {
        return new _MultiFactorError(auth2, error, operationType, user);
      }
    };
    MultiFactorInfoImpl = class {
      constructor(factorId, response) {
        this.factorId = factorId;
        this.uid = response.mfaEnrollmentId;
        this.enrollmentTime = new Date(response.enrolledAt).toUTCString();
        this.displayName = response.displayName;
      }
      static _fromServerResponse(auth2, enrollment) {
        if ("phoneInfo" in enrollment) {
          return PhoneMultiFactorInfoImpl._fromServerResponse(auth2, enrollment);
        } else if ("totpInfo" in enrollment) {
          return TotpMultiFactorInfoImpl._fromServerResponse(auth2, enrollment);
        }
        return _fail(
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
      }
    };
    PhoneMultiFactorInfoImpl = class _PhoneMultiFactorInfoImpl extends MultiFactorInfoImpl {
      constructor(response) {
        super("phone", response);
        this.phoneNumber = response.phoneInfo;
      }
      static _fromServerResponse(_auth, enrollment) {
        return new _PhoneMultiFactorInfoImpl(enrollment);
      }
    };
    TotpMultiFactorInfoImpl = class _TotpMultiFactorInfoImpl extends MultiFactorInfoImpl {
      constructor(response) {
        super("totp", response);
      }
      static _fromServerResponse(_auth, enrollment) {
        return new _TotpMultiFactorInfoImpl(enrollment);
      }
    };
    GenericAdditionalUserInfo = class {
      constructor(isNewUser, providerId, profile = {}) {
        this.isNewUser = isNewUser;
        this.providerId = providerId;
        this.profile = profile;
      }
    };
    FederatedAdditionalUserInfoWithUsername = class extends GenericAdditionalUserInfo {
      constructor(isNewUser, providerId, profile, username) {
        super(isNewUser, providerId, profile);
        this.username = username;
      }
    };
    FacebookAdditionalUserInfo = class extends GenericAdditionalUserInfo {
      constructor(isNewUser, profile) {
        super(isNewUser, "facebook.com", profile);
      }
    };
    GithubAdditionalUserInfo = class extends FederatedAdditionalUserInfoWithUsername {
      constructor(isNewUser, profile) {
        super(isNewUser, "github.com", profile, typeof profile?.login === "string" ? profile?.login : null);
      }
    };
    GoogleAdditionalUserInfo = class extends GenericAdditionalUserInfo {
      constructor(isNewUser, profile) {
        super(isNewUser, "google.com", profile);
      }
    };
    TwitterAdditionalUserInfo = class extends FederatedAdditionalUserInfoWithUsername {
      constructor(isNewUser, profile, screenName) {
        super(isNewUser, "twitter.com", profile, screenName);
      }
    };
    MultiFactorSessionImpl = class _MultiFactorSessionImpl {
      constructor(type, credential, user) {
        this.type = type;
        this.credential = credential;
        this.user = user;
      }
      static _fromIdtoken(idToken, user) {
        return new _MultiFactorSessionImpl("enroll", idToken, user);
      }
      static _fromMfaPendingCredential(mfaPendingCredential) {
        return new _MultiFactorSessionImpl("signin", mfaPendingCredential);
      }
      toJSON() {
        const key = this.type === "enroll" ? "idToken" : "pendingCredential";
        return {
          multiFactorSession: {
            [key]: this.credential
          }
        };
      }
      static fromJSON(obj) {
        if (obj?.multiFactorSession) {
          if (obj.multiFactorSession?.pendingCredential) {
            return _MultiFactorSessionImpl._fromMfaPendingCredential(obj.multiFactorSession.pendingCredential);
          } else if (obj.multiFactorSession?.idToken) {
            return _MultiFactorSessionImpl._fromIdtoken(obj.multiFactorSession.idToken);
          }
        }
        return null;
      }
    };
    MultiFactorResolverImpl = class _MultiFactorResolverImpl {
      constructor(session, hints, signInResolver) {
        this.session = session;
        this.hints = hints;
        this.signInResolver = signInResolver;
      }
      /** @internal */
      static _fromError(authExtern, error) {
        const auth2 = _castAuth(authExtern);
        const serverResponse = error.customData._serverResponse;
        const hints = (serverResponse.mfaInfo || []).map((enrollment) => MultiFactorInfoImpl._fromServerResponse(auth2, enrollment));
        _assert(
          serverResponse.mfaPendingCredential,
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const session = MultiFactorSessionImpl._fromMfaPendingCredential(serverResponse.mfaPendingCredential);
        return new _MultiFactorResolverImpl(session, hints, async (assertion) => {
          const mfaResponse = await assertion._process(auth2, session);
          delete serverResponse.mfaInfo;
          delete serverResponse.mfaPendingCredential;
          const idTokenResponse = {
            ...serverResponse,
            idToken: mfaResponse.idToken,
            refreshToken: mfaResponse.refreshToken
          };
          switch (error.operationType) {
            case "signIn":
              const userCredential = await UserCredentialImpl._fromIdTokenResponse(auth2, error.operationType, idTokenResponse);
              await auth2._updateCurrentUser(userCredential.user);
              return userCredential;
            case "reauthenticate":
              _assert(
                error.user,
                auth2,
                "internal-error"
                /* AuthErrorCode.INTERNAL_ERROR */
              );
              return UserCredentialImpl._forOperation(error.user, error.operationType, idTokenResponse);
            default:
              _fail(
                auth2,
                "internal-error"
                /* AuthErrorCode.INTERNAL_ERROR */
              );
          }
        });
      }
      async resolveSignIn(assertionExtern) {
        const assertion = assertionExtern;
        return this.signInResolver(assertion);
      }
    };
    MultiFactorUserImpl = class _MultiFactorUserImpl {
      constructor(user) {
        this.user = user;
        this.enrolledFactors = [];
        user._onReload((userInfo) => {
          if (userInfo.mfaInfo) {
            this.enrolledFactors = userInfo.mfaInfo.map((enrollment) => MultiFactorInfoImpl._fromServerResponse(user.auth, enrollment));
          }
        });
      }
      static _fromUser(user) {
        return new _MultiFactorUserImpl(user);
      }
      async getSession() {
        return MultiFactorSessionImpl._fromIdtoken(await this.user.getIdToken(), this.user);
      }
      async enroll(assertionExtern, displayName) {
        const assertion = assertionExtern;
        const session = await this.getSession();
        const finalizeMfaResponse = await _logoutIfInvalidated(this.user, assertion._process(this.user.auth, session, displayName));
        await this.user._updateTokensIfNecessary(finalizeMfaResponse);
        return this.user.reload();
      }
      async unenroll(infoOrUid) {
        const mfaEnrollmentId = typeof infoOrUid === "string" ? infoOrUid : infoOrUid.uid;
        const idToken = await this.user.getIdToken();
        try {
          const idTokenResponse = await _logoutIfInvalidated(this.user, withdrawMfa(this.user.auth, {
            idToken,
            mfaEnrollmentId
          }));
          this.enrolledFactors = this.enrolledFactors.filter(({ uid }) => uid !== mfaEnrollmentId);
          await this.user._updateTokensIfNecessary(idTokenResponse);
          await this.user.reload();
        } catch (e) {
          throw e;
        }
      }
    };
    multiFactorUserCache = /* @__PURE__ */ new WeakMap();
    name3 = "@firebase/auth";
    version3 = "1.11.1";
    AuthInterop = class {
      constructor(auth2) {
        this.auth = auth2;
        this.internalListeners = /* @__PURE__ */ new Map();
      }
      getUid() {
        this.assertAuthConfigured();
        return this.auth.currentUser?.uid || null;
      }
      async getToken(forceRefresh) {
        this.assertAuthConfigured();
        await this.auth._initializationPromise;
        if (!this.auth.currentUser) {
          return null;
        }
        const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);
        return { accessToken };
      }
      addAuthTokenListener(listener) {
        this.assertAuthConfigured();
        if (this.internalListeners.has(listener)) {
          return;
        }
        const unsubscribe = this.auth.onIdTokenChanged((user) => {
          listener(user?.stsTokenManager.accessToken || null);
        });
        this.internalListeners.set(listener, unsubscribe);
        this.updateProactiveRefresh();
      }
      removeAuthTokenListener(listener) {
        this.assertAuthConfigured();
        const unsubscribe = this.internalListeners.get(listener);
        if (!unsubscribe) {
          return;
        }
        this.internalListeners.delete(listener);
        unsubscribe();
        this.updateProactiveRefresh();
      }
      assertAuthConfigured() {
        _assert(
          this.auth._initializationPromise,
          "dependent-sdk-initialized-before-auth"
          /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
        );
      }
      updateProactiveRefresh() {
        if (this.internalListeners.size > 0) {
          this.auth._startProactiveRefresh();
        } else {
          this.auth._stopProactiveRefresh();
        }
      }
    };
    FetchProvider.initialize(fetch, Headers, Response);
    registerAuth(
      "Node"
      /* ClientPlatform.NODE */
    );
    NOT_AVAILABLE_ERROR = _createError(
      "operation-not-supported-in-this-environment"
      /* AuthErrorCode.OPERATION_NOT_SUPPORTED */
    );
    FailClass = class {
      constructor() {
        throw NOT_AVAILABLE_ERROR;
      }
    };
    browserLocalPersistence = inMemoryPersistence;
    browserSessionPersistence = inMemoryPersistence;
    browserCookiePersistence = inMemoryPersistence;
    indexedDBLocalPersistence = inMemoryPersistence;
    browserPopupRedirectResolver = NOT_AVAILABLE_ERROR;
    PhoneAuthProvider = FailClass;
    signInWithPhoneNumber = fail;
    linkWithPhoneNumber = fail;
    reauthenticateWithPhoneNumber = fail;
    updatePhoneNumber = fail;
    signInWithPopup = fail;
    linkWithPopup = fail;
    reauthenticateWithPopup = fail;
    signInWithRedirect = fail;
    linkWithRedirect = fail;
    reauthenticateWithRedirect = fail;
    getRedirectResult = fail;
    RecaptchaVerifier = FailClass;
    PhoneMultiFactorGenerator = class {
      static assertion() {
        throw NOT_AVAILABLE_ERROR;
      }
    };
    AuthImpl.prototype.setPersistence = async () => {
    };
    MultiFactorAssertionImpl = class {
      constructor(factorId) {
        this.factorId = factorId;
      }
      _process(auth2, session, displayName) {
        switch (session.type) {
          case "enroll":
            return this._finalizeEnroll(auth2, session.credential, displayName);
          case "signin":
            return this._finalizeSignIn(auth2, session.credential);
          default:
            return debugFail("unexpected MultiFactorSessionType");
        }
      }
    };
    TotpMultiFactorGenerator = class {
      /**
       * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of
       * the TOTP (time-based one-time password) second factor.
       * This assertion is used to complete enrollment in TOTP second factor.
       *
       * @param secret A {@link TotpSecret} containing the shared secret key and other TOTP parameters.
       * @param oneTimePassword One-time password from TOTP App.
       * @returns A {@link TotpMultiFactorAssertion} which can be used with
       * {@link MultiFactorUser.enroll}.
       */
      static assertionForEnrollment(secret, oneTimePassword) {
        return TotpMultiFactorAssertionImpl._fromSecret(secret, oneTimePassword);
      }
      /**
       * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of the TOTP second factor.
       * This assertion is used to complete signIn with TOTP as the second factor.
       *
       * @param enrollmentId identifies the enrolled TOTP second factor.
       * @param oneTimePassword One-time password from TOTP App.
       * @returns A {@link TotpMultiFactorAssertion} which can be used with
       * {@link MultiFactorResolver.resolveSignIn}.
       */
      static assertionForSignIn(enrollmentId, oneTimePassword) {
        return TotpMultiFactorAssertionImpl._fromEnrollmentId(enrollmentId, oneTimePassword);
      }
      /**
       * Returns a promise to {@link TotpSecret} which contains the TOTP shared secret key and other parameters.
       * Creates a TOTP secret as part of enrolling a TOTP second factor.
       * Used for generating a QR code URL or inputting into a TOTP app.
       * This method uses the auth instance corresponding to the user in the multiFactorSession.
       *
       * @param session The {@link MultiFactorSession} that the user is part of.
       * @returns A promise to {@link TotpSecret}.
       */
      static async generateSecret(session) {
        const mfaSession = session;
        _assert(
          typeof mfaSession.user?.auth !== "undefined",
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const response = await startEnrollTotpMfa(mfaSession.user.auth, {
          idToken: mfaSession.credential,
          totpEnrollmentInfo: {}
        });
        return TotpSecret._fromStartTotpMfaEnrollmentResponse(response, mfaSession.user.auth);
      }
    };
    TotpMultiFactorGenerator.FACTOR_ID = "totp";
    TotpMultiFactorAssertionImpl = class _TotpMultiFactorAssertionImpl extends MultiFactorAssertionImpl {
      constructor(otp, enrollmentId, secret) {
        super(
          "totp"
          /* FactorId.TOTP */
        );
        this.otp = otp;
        this.enrollmentId = enrollmentId;
        this.secret = secret;
      }
      /** @internal */
      static _fromSecret(secret, otp) {
        return new _TotpMultiFactorAssertionImpl(otp, void 0, secret);
      }
      /** @internal */
      static _fromEnrollmentId(enrollmentId, otp) {
        return new _TotpMultiFactorAssertionImpl(otp, enrollmentId);
      }
      /** @internal */
      async _finalizeEnroll(auth2, idToken, displayName) {
        _assert(
          typeof this.secret !== "undefined",
          auth2,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return finalizeEnrollTotpMfa(auth2, {
          idToken,
          displayName,
          totpVerificationInfo: this.secret._makeTotpVerificationInfo(this.otp)
        });
      }
      /** @internal */
      async _finalizeSignIn(auth2, mfaPendingCredential) {
        _assert(
          this.enrollmentId !== void 0 && this.otp !== void 0,
          auth2,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        const totpVerificationInfo = { verificationCode: this.otp };
        return finalizeSignInTotpMfa(auth2, {
          mfaPendingCredential,
          mfaEnrollmentId: this.enrollmentId,
          totpVerificationInfo
        });
      }
    };
    TotpSecret = class _TotpSecret {
      // The public members are declared outside the constructor so the docs can be generated.
      constructor(secretKey, hashingAlgorithm, codeLength, codeIntervalSeconds, enrollmentCompletionDeadline, sessionInfo, auth2) {
        this.sessionInfo = sessionInfo;
        this.auth = auth2;
        this.secretKey = secretKey;
        this.hashingAlgorithm = hashingAlgorithm;
        this.codeLength = codeLength;
        this.codeIntervalSeconds = codeIntervalSeconds;
        this.enrollmentCompletionDeadline = enrollmentCompletionDeadline;
      }
      /** @internal */
      static _fromStartTotpMfaEnrollmentResponse(response, auth2) {
        return new _TotpSecret(response.totpSessionInfo.sharedSecretKey, response.totpSessionInfo.hashingAlgorithm, response.totpSessionInfo.verificationCodeLength, response.totpSessionInfo.periodSec, new Date(response.totpSessionInfo.finalizeEnrollmentTime).toUTCString(), response.totpSessionInfo.sessionInfo, auth2);
      }
      /** @internal */
      _makeTotpVerificationInfo(otp) {
        return { sessionInfo: this.sessionInfo, verificationCode: otp };
      }
      /**
       * Returns a QR code URL as described in
       * https://github.com/google/google-authenticator/wiki/Key-Uri-Format
       * This can be displayed to the user as a QR code to be scanned into a TOTP app like Google Authenticator.
       * If the optional parameters are unspecified, an accountName of <userEmail> and issuer of <firebaseAppName> are used.
       *
       * @param accountName the name of the account/app along with a user identifier.
       * @param issuer issuer of the TOTP (likely the app name).
       * @returns A QR code URL string.
       */
      generateQrCodeUrl(accountName, issuer) {
        let useDefaults = false;
        if (_isEmptyString(accountName) || _isEmptyString(issuer)) {
          useDefaults = true;
        }
        if (useDefaults) {
          if (_isEmptyString(accountName)) {
            accountName = this.auth.currentUser?.email || "unknownuser";
          }
          if (_isEmptyString(issuer)) {
            issuer = this.auth.name;
          }
        }
        return `otpauth://totp/${issuer}:${accountName}?secret=${this.secretKey}&issuer=${issuer}&algorithm=${this.hashingAlgorithm}&digits=${this.codeLength}`;
      }
    };
  }
});

// node_modules/@firebase/auth/dist/node-esm/index.js
var init_node_esm = __esm({
  "node_modules/@firebase/auth/dist/node-esm/index.js"() {
    init_totp_c8d207b9();
    init_index_esm3();
    init_index_node_esm();
    init_index_esm();
    init_index_esm2();
  }
});

// node_modules/firebase/auth/dist/index.mjs
var dist_exports = {};
__export(dist_exports, {
  ActionCodeOperation: () => ActionCodeOperation,
  ActionCodeURL: () => ActionCodeURL,
  AuthCredential: () => AuthCredential,
  AuthErrorCodes: () => AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY,
  EmailAuthCredential: () => EmailAuthCredential,
  EmailAuthProvider: () => EmailAuthProvider,
  FacebookAuthProvider: () => FacebookAuthProvider,
  FactorId: () => FactorId,
  GithubAuthProvider: () => GithubAuthProvider,
  GoogleAuthProvider: () => GoogleAuthProvider,
  OAuthCredential: () => OAuthCredential,
  OAuthProvider: () => OAuthProvider,
  OperationType: () => OperationType,
  PhoneAuthCredential: () => PhoneAuthCredential,
  PhoneAuthProvider: () => PhoneAuthProvider,
  PhoneMultiFactorGenerator: () => PhoneMultiFactorGenerator,
  ProviderId: () => ProviderId,
  RecaptchaVerifier: () => RecaptchaVerifier,
  SAMLAuthProvider: () => SAMLAuthProvider,
  SignInMethod: () => SignInMethod,
  TotpMultiFactorGenerator: () => TotpMultiFactorGenerator,
  TotpSecret: () => TotpSecret,
  TwitterAuthProvider: () => TwitterAuthProvider,
  applyActionCode: () => applyActionCode,
  beforeAuthStateChanged: () => beforeAuthStateChanged,
  browserCookiePersistence: () => browserCookiePersistence,
  browserLocalPersistence: () => browserLocalPersistence,
  browserPopupRedirectResolver: () => browserPopupRedirectResolver,
  browserSessionPersistence: () => browserSessionPersistence,
  checkActionCode: () => checkActionCode,
  confirmPasswordReset: () => confirmPasswordReset,
  connectAuthEmulator: () => connectAuthEmulator,
  createUserWithEmailAndPassword: () => createUserWithEmailAndPassword,
  debugErrorMap: () => debugErrorMap,
  deleteUser: () => deleteUser,
  fetchSignInMethodsForEmail: () => fetchSignInMethodsForEmail,
  getAdditionalUserInfo: () => getAdditionalUserInfo,
  getAuth: () => getAuth,
  getIdToken: () => getIdToken,
  getIdTokenResult: () => getIdTokenResult,
  getMultiFactorResolver: () => getMultiFactorResolver,
  getRedirectResult: () => getRedirectResult,
  inMemoryPersistence: () => inMemoryPersistence,
  indexedDBLocalPersistence: () => indexedDBLocalPersistence,
  initializeAuth: () => initializeAuth,
  initializeRecaptchaConfig: () => initializeRecaptchaConfig,
  isSignInWithEmailLink: () => isSignInWithEmailLink,
  linkWithCredential: () => linkWithCredential,
  linkWithPhoneNumber: () => linkWithPhoneNumber,
  linkWithPopup: () => linkWithPopup,
  linkWithRedirect: () => linkWithRedirect,
  multiFactor: () => multiFactor,
  onAuthStateChanged: () => onAuthStateChanged,
  onIdTokenChanged: () => onIdTokenChanged,
  parseActionCodeURL: () => parseActionCodeURL,
  prodErrorMap: () => prodErrorMap,
  reauthenticateWithCredential: () => reauthenticateWithCredential,
  reauthenticateWithPhoneNumber: () => reauthenticateWithPhoneNumber,
  reauthenticateWithPopup: () => reauthenticateWithPopup,
  reauthenticateWithRedirect: () => reauthenticateWithRedirect,
  reload: () => reload,
  revokeAccessToken: () => revokeAccessToken,
  sendEmailVerification: () => sendEmailVerification,
  sendPasswordResetEmail: () => sendPasswordResetEmail,
  sendSignInLinkToEmail: () => sendSignInLinkToEmail,
  setPersistence: () => setPersistence,
  signInAnonymously: () => signInAnonymously,
  signInWithCredential: () => signInWithCredential,
  signInWithCustomToken: () => signInWithCustomToken,
  signInWithEmailAndPassword: () => signInWithEmailAndPassword,
  signInWithEmailLink: () => signInWithEmailLink,
  signInWithPhoneNumber: () => signInWithPhoneNumber,
  signInWithPopup: () => signInWithPopup,
  signInWithRedirect: () => signInWithRedirect,
  signOut: () => signOut,
  unlink: () => unlink,
  updateCurrentUser: () => updateCurrentUser,
  updateEmail: () => updateEmail,
  updatePassword: () => updatePassword,
  updatePhoneNumber: () => updatePhoneNumber,
  updateProfile: () => updateProfile,
  useDeviceLanguage: () => useDeviceLanguage,
  validatePassword: () => validatePassword,
  verifyBeforeUpdateEmail: () => verifyBeforeUpdateEmail,
  verifyPasswordResetCode: () => verifyPasswordResetCode
});
var init_dist2 = __esm({
  "node_modules/firebase/auth/dist/index.mjs"() {
    init_node_esm();
  }
});

// node_modules/@firebase/functions/dist/esm/index.esm.js
function mapValues(o, f) {
  const result = {};
  for (const key in o) {
    if (o.hasOwnProperty(key)) {
      result[key] = f(o[key]);
    }
  }
  return result;
}
function encode(data) {
  if (data == null) {
    return null;
  }
  if (data instanceof Number) {
    data = data.valueOf();
  }
  if (typeof data === "number" && isFinite(data)) {
    return data;
  }
  if (data === true || data === false) {
    return data;
  }
  if (Object.prototype.toString.call(data) === "[object String]") {
    return data;
  }
  if (data instanceof Date) {
    return data.toISOString();
  }
  if (Array.isArray(data)) {
    return data.map((x) => encode(x));
  }
  if (typeof data === "function" || typeof data === "object") {
    return mapValues(data, (x) => encode(x));
  }
  throw new Error("Data cannot be encoded in JSON: " + data);
}
function decode(json) {
  if (json == null) {
    return json;
  }
  if (json["@type"]) {
    switch (json["@type"]) {
      case LONG_TYPE:
      // Fall through and handle this the same as unsigned.
      case UNSIGNED_LONG_TYPE: {
        const value = Number(json["value"]);
        if (isNaN(value)) {
          throw new Error("Data cannot be decoded from JSON: " + json);
        }
        return value;
      }
      default: {
        throw new Error("Data cannot be decoded from JSON: " + json);
      }
    }
  }
  if (Array.isArray(json)) {
    return json.map((x) => decode(x));
  }
  if (typeof json === "function" || typeof json === "object") {
    return mapValues(json, (x) => decode(x));
  }
  return json;
}
function codeForHTTPStatus(status) {
  if (status >= 200 && status < 300) {
    return "ok";
  }
  switch (status) {
    case 0:
      return "internal";
    case 400:
      return "invalid-argument";
    case 401:
      return "unauthenticated";
    case 403:
      return "permission-denied";
    case 404:
      return "not-found";
    case 409:
      return "aborted";
    case 429:
      return "resource-exhausted";
    case 499:
      return "cancelled";
    case 500:
      return "internal";
    case 501:
      return "unimplemented";
    case 503:
      return "unavailable";
    case 504:
      return "deadline-exceeded";
  }
  return "unknown";
}
function _errorForResponse(status, bodyJSON) {
  let code = codeForHTTPStatus(status);
  let description = code;
  let details = void 0;
  try {
    const errorJSON = bodyJSON && bodyJSON.error;
    if (errorJSON) {
      const status2 = errorJSON.status;
      if (typeof status2 === "string") {
        if (!errorCodeMap[status2]) {
          return new FunctionsError("internal", "internal");
        }
        code = errorCodeMap[status2];
        description = status2;
      }
      const message = errorJSON.message;
      if (typeof message === "string") {
        description = message;
      }
      details = errorJSON.details;
      if (details !== void 0) {
        details = decode(details);
      }
    }
  } catch (e) {
  }
  if (code === "ok") {
    return null;
  }
  return new FunctionsError(code, description, details);
}
function failAfter(millis) {
  let timer = null;
  return {
    promise: new Promise((_, reject) => {
      timer = setTimeout(() => {
        reject(new FunctionsError("deadline-exceeded", "deadline-exceeded"));
      }, millis);
    }),
    cancel: () => {
      if (timer) {
        clearTimeout(timer);
      }
    }
  };
}
function connectFunctionsEmulator$1(functionsInstance, host, port) {
  const useSsl = isCloudWorkstation(host);
  functionsInstance.emulatorOrigin = `http${useSsl ? "s" : ""}://${host}:${port}`;
  if (useSsl) {
    void pingServer(functionsInstance.emulatorOrigin + "/backends");
    updateEmulatorBanner("Functions", true);
  }
}
function httpsCallable$1(functionsInstance, name6, options) {
  const callable = (data) => {
    return call(functionsInstance, name6, data, options || {});
  };
  callable.stream = (data, options2) => {
    return stream(functionsInstance, name6, data, options2);
  };
  return callable;
}
function httpsCallableFromURL$1(functionsInstance, url, options) {
  const callable = (data) => {
    return callAtURL(functionsInstance, url, data, options || {});
  };
  callable.stream = (data, options2) => {
    return streamAtURL(functionsInstance, url, data, options2 || {});
  };
  return callable;
}
function getCredentials(functionsInstance) {
  return functionsInstance.emulatorOrigin && isCloudWorkstation(functionsInstance.emulatorOrigin) ? "include" : void 0;
}
async function postJSON(url, body, headers, fetchImpl, functionsInstance) {
  headers["Content-Type"] = "application/json";
  let response;
  try {
    response = await fetchImpl(url, {
      method: "POST",
      body: JSON.stringify(body),
      headers,
      credentials: getCredentials(functionsInstance)
    });
  } catch (e) {
    return {
      status: 0,
      json: null
    };
  }
  let json = null;
  try {
    json = await response.json();
  } catch (e) {
  }
  return {
    status: response.status,
    json
  };
}
async function makeAuthHeaders(functionsInstance, options) {
  const headers = {};
  const context = await functionsInstance.contextProvider.getContext(options.limitedUseAppCheckTokens);
  if (context.authToken) {
    headers["Authorization"] = "Bearer " + context.authToken;
  }
  if (context.messagingToken) {
    headers["Firebase-Instance-ID-Token"] = context.messagingToken;
  }
  if (context.appCheckToken !== null) {
    headers["X-Firebase-AppCheck"] = context.appCheckToken;
  }
  return headers;
}
function call(functionsInstance, name6, data, options) {
  const url = functionsInstance._url(name6);
  return callAtURL(functionsInstance, url, data, options);
}
async function callAtURL(functionsInstance, url, data, options) {
  data = encode(data);
  const body = { data };
  const headers = await makeAuthHeaders(functionsInstance, options);
  const timeout = options.timeout || 7e4;
  const failAfterHandle = failAfter(timeout);
  const response = await Promise.race([
    postJSON(url, body, headers, functionsInstance.fetchImpl, functionsInstance),
    failAfterHandle.promise,
    functionsInstance.cancelAllRequests
  ]);
  failAfterHandle.cancel();
  if (!response) {
    throw new FunctionsError("cancelled", "Firebase Functions instance was deleted.");
  }
  const error = _errorForResponse(response.status, response.json);
  if (error) {
    throw error;
  }
  if (!response.json) {
    throw new FunctionsError("internal", "Response is not valid JSON object.");
  }
  let responseData = response.json.data;
  if (typeof responseData === "undefined") {
    responseData = response.json.result;
  }
  if (typeof responseData === "undefined") {
    throw new FunctionsError("internal", "Response is missing data field.");
  }
  const decodedData = decode(responseData);
  return { data: decodedData };
}
function stream(functionsInstance, name6, data, options) {
  const url = functionsInstance._url(name6);
  return streamAtURL(functionsInstance, url, data, options || {});
}
async function streamAtURL(functionsInstance, url, data, options) {
  data = encode(data);
  const body = { data };
  const headers = await makeAuthHeaders(functionsInstance, options);
  headers["Content-Type"] = "application/json";
  headers["Accept"] = "text/event-stream";
  let response;
  try {
    response = await functionsInstance.fetchImpl(url, {
      method: "POST",
      body: JSON.stringify(body),
      headers,
      signal: options?.signal,
      credentials: getCredentials(functionsInstance)
    });
  } catch (e) {
    if (e instanceof Error && e.name === "AbortError") {
      const error2 = new FunctionsError("cancelled", "Request was cancelled.");
      return {
        data: Promise.reject(error2),
        stream: {
          [Symbol.asyncIterator]() {
            return {
              next() {
                return Promise.reject(error2);
              }
            };
          }
        }
      };
    }
    const error = _errorForResponse(0, null);
    return {
      data: Promise.reject(error),
      // Return an empty async iterator
      stream: {
        [Symbol.asyncIterator]() {
          return {
            next() {
              return Promise.reject(error);
            }
          };
        }
      }
    };
  }
  let resultResolver;
  let resultRejecter;
  const resultPromise = new Promise((resolve, reject) => {
    resultResolver = resolve;
    resultRejecter = reject;
  });
  options?.signal?.addEventListener("abort", () => {
    const error = new FunctionsError("cancelled", "Request was cancelled.");
    resultRejecter(error);
  });
  const reader = response.body.getReader();
  const rstream = createResponseStream(reader, resultResolver, resultRejecter, options?.signal);
  return {
    stream: {
      [Symbol.asyncIterator]() {
        const rreader = rstream.getReader();
        return {
          async next() {
            const { value, done } = await rreader.read();
            return { value, done };
          },
          async return() {
            await rreader.cancel();
            return { done: true, value: void 0 };
          }
        };
      }
    },
    data: resultPromise
  };
}
function createResponseStream(reader, resultResolver, resultRejecter, signal) {
  const processLine = (line, controller) => {
    const match = line.match(responseLineRE);
    if (!match) {
      return;
    }
    const data = match[1];
    try {
      const jsonData = JSON.parse(data);
      if ("result" in jsonData) {
        resultResolver(decode(jsonData.result));
        return;
      }
      if ("message" in jsonData) {
        controller.enqueue(decode(jsonData.message));
        return;
      }
      if ("error" in jsonData) {
        const error = _errorForResponse(0, jsonData);
        controller.error(error);
        resultRejecter(error);
        return;
      }
    } catch (error) {
      if (error instanceof FunctionsError) {
        controller.error(error);
        resultRejecter(error);
        return;
      }
    }
  };
  const decoder = new TextDecoder();
  return new ReadableStream({
    start(controller) {
      let currentText = "";
      return pump();
      async function pump() {
        if (signal?.aborted) {
          const error = new FunctionsError("cancelled", "Request was cancelled");
          controller.error(error);
          resultRejecter(error);
          return Promise.resolve();
        }
        try {
          const { value, done } = await reader.read();
          if (done) {
            if (currentText.trim()) {
              processLine(currentText.trim(), controller);
            }
            controller.close();
            return;
          }
          if (signal?.aborted) {
            const error = new FunctionsError("cancelled", "Request was cancelled");
            controller.error(error);
            resultRejecter(error);
            await reader.cancel();
            return;
          }
          currentText += decoder.decode(value, { stream: true });
          const lines = currentText.split("\n");
          currentText = lines.pop() || "";
          for (const line of lines) {
            if (line.trim()) {
              processLine(line.trim(), controller);
            }
          }
          return pump();
        } catch (error) {
          const functionsError = error instanceof FunctionsError ? error : _errorForResponse(0, null);
          controller.error(functionsError);
          resultRejecter(functionsError);
        }
      }
    },
    cancel() {
      return reader.cancel();
    }
  });
}
function registerFunctions(variant) {
  const factory2 = (container, { instanceIdentifier: regionOrCustomDomain }) => {
    const app2 = container.getProvider("app").getImmediate();
    const authProvider = container.getProvider(AUTH_INTERNAL_NAME);
    const messagingProvider = container.getProvider(MESSAGING_INTERNAL_NAME);
    const appCheckProvider = container.getProvider(APP_CHECK_INTERNAL_NAME);
    return new FunctionsService(app2, authProvider, messagingProvider, appCheckProvider, regionOrCustomDomain);
  };
  _registerComponent(new Component(
    FUNCTIONS_TYPE,
    factory2,
    "PUBLIC"
    /* ComponentType.PUBLIC */
  ).setMultipleInstances(true));
  registerVersion(name4, version4, variant);
  registerVersion(name4, version4, "esm2020");
}
function getFunctions(app2 = getApp(), regionOrCustomDomain = DEFAULT_REGION) {
  const functionsProvider = _getProvider(getModularInstance(app2), FUNCTIONS_TYPE);
  const functionsInstance = functionsProvider.getImmediate({
    identifier: regionOrCustomDomain
  });
  const emulator = getDefaultEmulatorHostnameAndPort("functions");
  if (emulator) {
    connectFunctionsEmulator(functionsInstance, ...emulator);
  }
  return functionsInstance;
}
function connectFunctionsEmulator(functionsInstance, host, port) {
  connectFunctionsEmulator$1(getModularInstance(functionsInstance), host, port);
}
function httpsCallable(functionsInstance, name6, options) {
  return httpsCallable$1(getModularInstance(functionsInstance), name6, options);
}
function httpsCallableFromURL(functionsInstance, url, options) {
  return httpsCallableFromURL$1(getModularInstance(functionsInstance), url, options);
}
var LONG_TYPE, UNSIGNED_LONG_TYPE, FUNCTIONS_TYPE, errorCodeMap, FunctionsError, ContextProvider, DEFAULT_REGION, responseLineRE, FunctionsService, name4, version4, AUTH_INTERNAL_NAME, APP_CHECK_INTERNAL_NAME, MESSAGING_INTERNAL_NAME;
var init_index_esm4 = __esm({
  "node_modules/@firebase/functions/dist/esm/index.esm.js"() {
    init_index_esm3();
    init_index_node_esm();
    init_index_esm();
    LONG_TYPE = "type.googleapis.com/google.protobuf.Int64Value";
    UNSIGNED_LONG_TYPE = "type.googleapis.com/google.protobuf.UInt64Value";
    FUNCTIONS_TYPE = "functions";
    errorCodeMap = {
      OK: "ok",
      CANCELLED: "cancelled",
      UNKNOWN: "unknown",
      INVALID_ARGUMENT: "invalid-argument",
      DEADLINE_EXCEEDED: "deadline-exceeded",
      NOT_FOUND: "not-found",
      ALREADY_EXISTS: "already-exists",
      PERMISSION_DENIED: "permission-denied",
      UNAUTHENTICATED: "unauthenticated",
      RESOURCE_EXHAUSTED: "resource-exhausted",
      FAILED_PRECONDITION: "failed-precondition",
      ABORTED: "aborted",
      OUT_OF_RANGE: "out-of-range",
      UNIMPLEMENTED: "unimplemented",
      INTERNAL: "internal",
      UNAVAILABLE: "unavailable",
      DATA_LOSS: "data-loss"
    };
    FunctionsError = class _FunctionsError extends FirebaseError {
      /**
       * Constructs a new instance of the `FunctionsError` class.
       */
      constructor(code, message, details) {
        super(`${FUNCTIONS_TYPE}/${code}`, message || "");
        this.details = details;
        Object.setPrototypeOf(this, _FunctionsError.prototype);
      }
    };
    ContextProvider = class {
      constructor(app2, authProvider, messagingProvider, appCheckProvider) {
        this.app = app2;
        this.auth = null;
        this.messaging = null;
        this.appCheck = null;
        this.serverAppAppCheckToken = null;
        if (_isFirebaseServerApp(app2) && app2.settings.appCheckToken) {
          this.serverAppAppCheckToken = app2.settings.appCheckToken;
        }
        this.auth = authProvider.getImmediate({ optional: true });
        this.messaging = messagingProvider.getImmediate({
          optional: true
        });
        if (!this.auth) {
          authProvider.get().then((auth2) => this.auth = auth2, () => {
          });
        }
        if (!this.messaging) {
          messagingProvider.get().then((messaging) => this.messaging = messaging, () => {
          });
        }
        if (!this.appCheck) {
          appCheckProvider?.get().then((appCheck) => this.appCheck = appCheck, () => {
          });
        }
      }
      async getAuthToken() {
        if (!this.auth) {
          return void 0;
        }
        try {
          const token = await this.auth.getToken();
          return token?.accessToken;
        } catch (e) {
          return void 0;
        }
      }
      async getMessagingToken() {
        if (!this.messaging || !("Notification" in self) || Notification.permission !== "granted") {
          return void 0;
        }
        try {
          return await this.messaging.getToken();
        } catch (e) {
          return void 0;
        }
      }
      async getAppCheckToken(limitedUseAppCheckTokens) {
        if (this.serverAppAppCheckToken) {
          return this.serverAppAppCheckToken;
        }
        if (this.appCheck) {
          const result = limitedUseAppCheckTokens ? await this.appCheck.getLimitedUseToken() : await this.appCheck.getToken();
          if (result.error) {
            return null;
          }
          return result.token;
        }
        return null;
      }
      async getContext(limitedUseAppCheckTokens) {
        const authToken = await this.getAuthToken();
        const messagingToken = await this.getMessagingToken();
        const appCheckToken = await this.getAppCheckToken(limitedUseAppCheckTokens);
        return { authToken, messagingToken, appCheckToken };
      }
    };
    DEFAULT_REGION = "us-central1";
    responseLineRE = /^data: (.*?)(?:\n|$)/;
    FunctionsService = class {
      /**
       * Creates a new Functions service for the given app.
       * @param app - The FirebaseApp to use.
       */
      constructor(app2, authProvider, messagingProvider, appCheckProvider, regionOrCustomDomain = DEFAULT_REGION, fetchImpl = (...args) => fetch(...args)) {
        this.app = app2;
        this.fetchImpl = fetchImpl;
        this.emulatorOrigin = null;
        this.contextProvider = new ContextProvider(app2, authProvider, messagingProvider, appCheckProvider);
        this.cancelAllRequests = new Promise((resolve) => {
          this.deleteService = () => {
            return Promise.resolve(resolve());
          };
        });
        try {
          const url = new URL(regionOrCustomDomain);
          this.customDomain = url.origin + (url.pathname === "/" ? "" : url.pathname);
          this.region = DEFAULT_REGION;
        } catch (e) {
          this.customDomain = null;
          this.region = regionOrCustomDomain;
        }
      }
      _delete() {
        return this.deleteService();
      }
      /**
       * Returns the URL for a callable with the given name.
       * @param name - The name of the callable.
       * @internal
       */
      _url(name6) {
        const projectId = this.app.options.projectId;
        if (this.emulatorOrigin !== null) {
          const origin = this.emulatorOrigin;
          return `${origin}/${projectId}/${this.region}/${name6}`;
        }
        if (this.customDomain !== null) {
          return `${this.customDomain}/${name6}`;
        }
        return `https://${this.region}-${projectId}.cloudfunctions.net/${name6}`;
      }
    };
    name4 = "@firebase/functions";
    version4 = "0.13.1";
    AUTH_INTERNAL_NAME = "auth-internal";
    APP_CHECK_INTERNAL_NAME = "app-check-internal";
    MESSAGING_INTERNAL_NAME = "messaging-internal";
    registerFunctions();
  }
});

// node_modules/firebase/functions/dist/index.mjs
var dist_exports2 = {};
__export(dist_exports2, {
  FunctionsError: () => FunctionsError,
  connectFunctionsEmulator: () => connectFunctionsEmulator,
  getFunctions: () => getFunctions,
  httpsCallable: () => httpsCallable,
  httpsCallableFromURL: () => httpsCallableFromURL
});
var init_dist3 = __esm({
  "node_modules/firebase/functions/dist/index.mjs"() {
    init_index_esm4();
  }
});

// node_modules/@firebase/storage/dist/node-esm/index.node.esm.js
function prependCode(code) {
  return "storage/" + code;
}
function unknown() {
  const message = "An unknown error occurred, please check the error payload for server response.";
  return new StorageError(StorageErrorCode.UNKNOWN, message);
}
function objectNotFound(path) {
  return new StorageError(StorageErrorCode.OBJECT_NOT_FOUND, "Object '" + path + "' does not exist.");
}
function quotaExceeded(bucket) {
  return new StorageError(StorageErrorCode.QUOTA_EXCEEDED, "Quota for bucket '" + bucket + "' exceeded, please view quota on https://firebase.google.com/pricing/.");
}
function unauthenticated() {
  const message = "User is not authenticated, please authenticate using Firebase Authentication and try again.";
  return new StorageError(StorageErrorCode.UNAUTHENTICATED, message);
}
function unauthorizedApp() {
  return new StorageError(StorageErrorCode.UNAUTHORIZED_APP, "This app does not have permission to access Firebase Storage on this project.");
}
function unauthorized(path) {
  return new StorageError(StorageErrorCode.UNAUTHORIZED, "User does not have permission to access '" + path + "'.");
}
function retryLimitExceeded() {
  return new StorageError(StorageErrorCode.RETRY_LIMIT_EXCEEDED, "Max retry time for operation exceeded, please try again.");
}
function canceled() {
  return new StorageError(StorageErrorCode.CANCELED, "User canceled the upload/download.");
}
function invalidUrl(url) {
  return new StorageError(StorageErrorCode.INVALID_URL, "Invalid URL '" + url + "'.");
}
function invalidDefaultBucket(bucket) {
  return new StorageError(StorageErrorCode.INVALID_DEFAULT_BUCKET, "Invalid default bucket '" + bucket + "'.");
}
function noDefaultBucket() {
  return new StorageError(StorageErrorCode.NO_DEFAULT_BUCKET, "No default bucket found. Did you set the '" + CONFIG_STORAGE_BUCKET_KEY + "' property when initializing the app?");
}
function cannotSliceBlob() {
  return new StorageError(StorageErrorCode.CANNOT_SLICE_BLOB, "Cannot slice blob for upload. Please retry the upload.");
}
function noDownloadURL() {
  return new StorageError(StorageErrorCode.NO_DOWNLOAD_URL, "The given file does not have any download URLs.");
}
function invalidArgument(message) {
  return new StorageError(StorageErrorCode.INVALID_ARGUMENT, message);
}
function appDeleted() {
  return new StorageError(StorageErrorCode.APP_DELETED, "The Firebase app was deleted.");
}
function invalidRootOperation(name6) {
  return new StorageError(StorageErrorCode.INVALID_ROOT_OPERATION, "The operation '" + name6 + "' cannot be performed on a root reference, create a non-root reference using child, such as .child('file.png').");
}
function invalidFormat(format, message) {
  return new StorageError(StorageErrorCode.INVALID_FORMAT, "String does not match format '" + format + "': " + message);
}
function internalError(message) {
  throw new StorageError(StorageErrorCode.INTERNAL_ERROR, "Internal error: " + message);
}
function start(doRequest, backoffCompleteCb, timeout) {
  let waitSeconds = 1;
  let retryTimeoutId = null;
  let globalTimeoutId = null;
  let hitTimeout = false;
  let cancelState = 0;
  function canceled2() {
    return cancelState === 2;
  }
  let triggeredCallback = false;
  function triggerCallback(...args) {
    if (!triggeredCallback) {
      triggeredCallback = true;
      backoffCompleteCb.apply(null, args);
    }
  }
  function callWithDelay(millis) {
    retryTimeoutId = setTimeout(() => {
      retryTimeoutId = null;
      doRequest(responseHandler, canceled2());
    }, millis);
  }
  function clearGlobalTimeout() {
    if (globalTimeoutId) {
      clearTimeout(globalTimeoutId);
    }
  }
  function responseHandler(success, ...args) {
    if (triggeredCallback) {
      clearGlobalTimeout();
      return;
    }
    if (success) {
      clearGlobalTimeout();
      triggerCallback.call(null, success, ...args);
      return;
    }
    const mustStop = canceled2() || hitTimeout;
    if (mustStop) {
      clearGlobalTimeout();
      triggerCallback.call(null, success, ...args);
      return;
    }
    if (waitSeconds < 64) {
      waitSeconds *= 2;
    }
    let waitMillis;
    if (cancelState === 1) {
      cancelState = 2;
      waitMillis = 0;
    } else {
      waitMillis = (waitSeconds + Math.random()) * 1e3;
    }
    callWithDelay(waitMillis);
  }
  let stopped = false;
  function stop2(wasTimeout) {
    if (stopped) {
      return;
    }
    stopped = true;
    clearGlobalTimeout();
    if (triggeredCallback) {
      return;
    }
    if (retryTimeoutId !== null) {
      if (!wasTimeout) {
        cancelState = 2;
      }
      clearTimeout(retryTimeoutId);
      callWithDelay(0);
    } else {
      if (!wasTimeout) {
        cancelState = 1;
      }
    }
  }
  callWithDelay(0);
  globalTimeoutId = setTimeout(() => {
    hitTimeout = true;
    stop2(true);
  }, timeout);
  return stop2;
}
function stop(id) {
  id(false);
}
function isJustDef(p) {
  return p !== void 0;
}
function isNonArrayObject(p) {
  return typeof p === "object" && !Array.isArray(p);
}
function isString(p) {
  return typeof p === "string" || p instanceof String;
}
function isNativeBlob(p) {
  return isNativeBlobDefined() && p instanceof Blob;
}
function isNativeBlobDefined() {
  return typeof Blob !== "undefined";
}
function validateNumber(argument, minValue, maxValue, value) {
  if (value < minValue) {
    throw invalidArgument(`Invalid value for '${argument}'. Expected ${minValue} or greater.`);
  }
  if (value > maxValue) {
    throw invalidArgument(`Invalid value for '${argument}'. Expected ${maxValue} or less.`);
  }
}
function makeUrl(urlPart, host, protocol) {
  let origin = host;
  if (protocol == null) {
    origin = `https://${host}`;
  }
  return `${protocol}://${origin}/v0${urlPart}`;
}
function makeQueryString(params) {
  const encode2 = encodeURIComponent;
  let queryPart = "?";
  for (const key in params) {
    if (params.hasOwnProperty(key)) {
      const nextPart = encode2(key) + "=" + encode2(params[key]);
      queryPart = queryPart + nextPart + "&";
    }
  }
  queryPart = queryPart.slice(0, -1);
  return queryPart;
}
function isRetryStatusCode(status, additionalRetryCodes) {
  const isFiveHundredCode = status >= 500 && status < 600;
  const extraRetryCodes = [
    // Request Timeout: web server didn't receive full request in time.
    408,
    // Too Many Requests: you're getting rate-limited, basically.
    429
  ];
  const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
  const isAdditionalRetryCode = additionalRetryCodes.indexOf(status) !== -1;
  return isFiveHundredCode || isExtraRetryCode || isAdditionalRetryCode;
}
function addAuthHeader_(headers, authToken) {
  if (authToken !== null && authToken.length > 0) {
    headers["Authorization"] = "Firebase " + authToken;
  }
}
function addVersionHeader_(headers, firebaseVersion) {
  headers["X-Firebase-Storage-Version"] = "webjs/" + (firebaseVersion ?? "AppManager");
}
function addGmpidHeader_(headers, appId) {
  if (appId) {
    headers["X-Firebase-GMPID"] = appId;
  }
}
function addAppCheckHeader_(headers, appCheckToken) {
  if (appCheckToken !== null) {
    headers["X-Firebase-AppCheck"] = appCheckToken;
  }
}
function makeRequest(requestInfo, appId, authToken, appCheckToken, requestFactory, firebaseVersion, retry = true, isUsingEmulator = false) {
  const queryPart = makeQueryString(requestInfo.urlParams);
  const url = requestInfo.url + queryPart;
  const headers = Object.assign({}, requestInfo.headers);
  addGmpidHeader_(headers, appId);
  addAuthHeader_(headers, authToken);
  addVersionHeader_(headers, firebaseVersion);
  addAppCheckHeader_(headers, appCheckToken);
  return new NetworkRequest(url, requestInfo.method, headers, requestInfo.body, requestInfo.successCodes, requestInfo.additionalRetryCodes, requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout, requestInfo.progressCallback, requestFactory, retry, isUsingEmulator);
}
function getBlobBuilder() {
  if (typeof BlobBuilder !== "undefined") {
    return BlobBuilder;
  } else if (typeof WebKitBlobBuilder !== "undefined") {
    return WebKitBlobBuilder;
  } else {
    return void 0;
  }
}
function getBlob$1(...args) {
  const BlobBuilder2 = getBlobBuilder();
  if (BlobBuilder2 !== void 0) {
    const bb = new BlobBuilder2();
    for (let i = 0; i < args.length; i++) {
      bb.append(args[i]);
    }
    return bb.getBlob();
  } else {
    if (isNativeBlobDefined()) {
      return new Blob(args);
    } else {
      throw new StorageError(StorageErrorCode.UNSUPPORTED_ENVIRONMENT, "This browser doesn't seem to support creating Blobs");
    }
  }
}
function sliceBlob(blob, start2, end) {
  if (blob.webkitSlice) {
    return blob.webkitSlice(start2, end);
  } else if (blob.mozSlice) {
    return blob.mozSlice(start2, end);
  } else if (blob.slice) {
    return blob.slice(start2, end);
  }
  return null;
}
function decodeBase64(encoded) {
  if (/[^-A-Za-z0-9+/=]/.test(encoded)) {
    throw invalidFormat("base64", "Invalid character found");
  }
  return Buffer.from(encoded, "base64").toString("binary");
}
function dataFromString(format, stringData) {
  switch (format) {
    case StringFormat.RAW:
      return new StringData(utf8Bytes_(stringData));
    case StringFormat.BASE64:
    case StringFormat.BASE64URL:
      return new StringData(base64Bytes_(format, stringData));
    case StringFormat.DATA_URL:
      return new StringData(dataURLBytes_(stringData), dataURLContentType_(stringData));
  }
  throw unknown();
}
function utf8Bytes_(value) {
  const b = [];
  for (let i = 0; i < value.length; i++) {
    let c = value.charCodeAt(i);
    if (c <= 127) {
      b.push(c);
    } else {
      if (c <= 2047) {
        b.push(192 | c >> 6, 128 | c & 63);
      } else {
        if ((c & 64512) === 55296) {
          const valid = i < value.length - 1 && (value.charCodeAt(i + 1) & 64512) === 56320;
          if (!valid) {
            b.push(239, 191, 189);
          } else {
            const hi = c;
            const lo = value.charCodeAt(++i);
            c = 65536 | (hi & 1023) << 10 | lo & 1023;
            b.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
          }
        } else {
          if ((c & 64512) === 56320) {
            b.push(239, 191, 189);
          } else {
            b.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
          }
        }
      }
    }
  }
  return new Uint8Array(b);
}
function percentEncodedBytes_(value) {
  let decoded;
  try {
    decoded = decodeURIComponent(value);
  } catch (e) {
    throw invalidFormat(StringFormat.DATA_URL, "Malformed data URL.");
  }
  return utf8Bytes_(decoded);
}
function base64Bytes_(format, value) {
  switch (format) {
    case StringFormat.BASE64: {
      const hasMinus = value.indexOf("-") !== -1;
      const hasUnder = value.indexOf("_") !== -1;
      if (hasMinus || hasUnder) {
        const invalidChar = hasMinus ? "-" : "_";
        throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64url encoded?");
      }
      break;
    }
    case StringFormat.BASE64URL: {
      const hasPlus = value.indexOf("+") !== -1;
      const hasSlash = value.indexOf("/") !== -1;
      if (hasPlus || hasSlash) {
        const invalidChar = hasPlus ? "+" : "/";
        throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64 encoded?");
      }
      value = value.replace(/-/g, "+").replace(/_/g, "/");
      break;
    }
  }
  let bytes;
  try {
    bytes = decodeBase64(value);
  } catch (e) {
    if (e.message.includes("polyfill")) {
      throw e;
    }
    throw invalidFormat(format, "Invalid character found");
  }
  const array = new Uint8Array(bytes.length);
  for (let i = 0; i < bytes.length; i++) {
    array[i] = bytes.charCodeAt(i);
  }
  return array;
}
function dataURLBytes_(dataUrl) {
  const parts = new DataURLParts(dataUrl);
  if (parts.base64) {
    return base64Bytes_(StringFormat.BASE64, parts.rest);
  } else {
    return percentEncodedBytes_(parts.rest);
  }
}
function dataURLContentType_(dataUrl) {
  const parts = new DataURLParts(dataUrl);
  return parts.contentType;
}
function endsWith(s, end) {
  const longEnough = s.length >= end.length;
  if (!longEnough) {
    return false;
  }
  return s.substring(s.length - end.length) === end;
}
function jsonObjectOrNull(s) {
  let obj;
  try {
    obj = JSON.parse(s);
  } catch (e) {
    return null;
  }
  if (isNonArrayObject(obj)) {
    return obj;
  } else {
    return null;
  }
}
function parent(path) {
  if (path.length === 0) {
    return null;
  }
  const index = path.lastIndexOf("/");
  if (index === -1) {
    return "";
  }
  const newPath = path.slice(0, index);
  return newPath;
}
function child(path, childPath) {
  const canonicalChildPath = childPath.split("/").filter((component) => component.length > 0).join("/");
  if (path.length === 0) {
    return canonicalChildPath;
  } else {
    return path + "/" + canonicalChildPath;
  }
}
function lastComponent(path) {
  const index = path.lastIndexOf("/", path.length - 2);
  if (index === -1) {
    return path;
  } else {
    return path.slice(index + 1);
  }
}
function noXform_(metadata, value) {
  return value;
}
function xformPath(fullPath) {
  if (!isString(fullPath) || fullPath.length < 2) {
    return fullPath;
  } else {
    return lastComponent(fullPath);
  }
}
function getMappings() {
  if (mappings_) {
    return mappings_;
  }
  const mappings = [];
  mappings.push(new Mapping("bucket"));
  mappings.push(new Mapping("generation"));
  mappings.push(new Mapping("metageneration"));
  mappings.push(new Mapping("name", "fullPath", true));
  function mappingsXformPath(_metadata, fullPath) {
    return xformPath(fullPath);
  }
  const nameMapping = new Mapping("name");
  nameMapping.xform = mappingsXformPath;
  mappings.push(nameMapping);
  function xformSize(_metadata, size) {
    if (size !== void 0) {
      return Number(size);
    } else {
      return size;
    }
  }
  const sizeMapping = new Mapping("size");
  sizeMapping.xform = xformSize;
  mappings.push(sizeMapping);
  mappings.push(new Mapping("timeCreated"));
  mappings.push(new Mapping("updated"));
  mappings.push(new Mapping("md5Hash", null, true));
  mappings.push(new Mapping("cacheControl", null, true));
  mappings.push(new Mapping("contentDisposition", null, true));
  mappings.push(new Mapping("contentEncoding", null, true));
  mappings.push(new Mapping("contentLanguage", null, true));
  mappings.push(new Mapping("contentType", null, true));
  mappings.push(new Mapping("metadata", "customMetadata", true));
  mappings_ = mappings;
  return mappings_;
}
function addRef(metadata, service) {
  function generateRef() {
    const bucket = metadata["bucket"];
    const path = metadata["fullPath"];
    const loc = new Location(bucket, path);
    return service._makeStorageReference(loc);
  }
  Object.defineProperty(metadata, "ref", { get: generateRef });
}
function fromResource(service, resource, mappings) {
  const metadata = {};
  metadata["type"] = "file";
  const len = mappings.length;
  for (let i = 0; i < len; i++) {
    const mapping = mappings[i];
    metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);
  }
  addRef(metadata, service);
  return metadata;
}
function fromResourceString(service, resourceString, mappings) {
  const obj = jsonObjectOrNull(resourceString);
  if (obj === null) {
    return null;
  }
  const resource = obj;
  return fromResource(service, resource, mappings);
}
function downloadUrlFromResourceString(metadata, resourceString, host, protocol) {
  const obj = jsonObjectOrNull(resourceString);
  if (obj === null) {
    return null;
  }
  if (!isString(obj["downloadTokens"])) {
    return null;
  }
  const tokens = obj["downloadTokens"];
  if (tokens.length === 0) {
    return null;
  }
  const encode2 = encodeURIComponent;
  const tokensList = tokens.split(",");
  const urls = tokensList.map((token) => {
    const bucket = metadata["bucket"];
    const path = metadata["fullPath"];
    const urlPart = "/b/" + encode2(bucket) + "/o/" + encode2(path);
    const base = makeUrl(urlPart, host, protocol);
    const queryString = makeQueryString({
      alt: "media",
      token
    });
    return base + queryString;
  });
  return urls[0];
}
function toResourceString(metadata, mappings) {
  const resource = {};
  const len = mappings.length;
  for (let i = 0; i < len; i++) {
    const mapping = mappings[i];
    if (mapping.writable) {
      resource[mapping.server] = metadata[mapping.local];
    }
  }
  return JSON.stringify(resource);
}
function handlerCheck(cndn) {
  if (!cndn) {
    throw unknown();
  }
}
function metadataHandler(service, mappings) {
  function handler(xhr, text) {
    const metadata = fromResourceString(service, text, mappings);
    handlerCheck(metadata !== null);
    return metadata;
  }
  return handler;
}
function downloadUrlHandler(service, mappings) {
  function handler(xhr, text) {
    const metadata = fromResourceString(service, text, mappings);
    handlerCheck(metadata !== null);
    return downloadUrlFromResourceString(metadata, text, service.host, service._protocol);
  }
  return handler;
}
function sharedErrorHandler(location) {
  function errorHandler(xhr, err) {
    let newErr;
    if (xhr.getStatus() === 401) {
      if (
        // This exact message string is the only consistent part of the
        // server's error response that identifies it as an App Check error.
        xhr.getErrorText().includes("Firebase App Check token is invalid")
      ) {
        newErr = unauthorizedApp();
      } else {
        newErr = unauthenticated();
      }
    } else {
      if (xhr.getStatus() === 402) {
        newErr = quotaExceeded(location.bucket);
      } else {
        if (xhr.getStatus() === 403) {
          newErr = unauthorized(location.path);
        } else {
          newErr = err;
        }
      }
    }
    newErr.status = xhr.getStatus();
    newErr.serverResponse = err.serverResponse;
    return newErr;
  }
  return errorHandler;
}
function objectErrorHandler(location) {
  const shared = sharedErrorHandler(location);
  function errorHandler(xhr, err) {
    let newErr = shared(xhr, err);
    if (xhr.getStatus() === 404) {
      newErr = objectNotFound(location.path);
    }
    newErr.serverResponse = err.serverResponse;
    return newErr;
  }
  return errorHandler;
}
function getDownloadUrl(service, location, mappings) {
  const urlPart = location.fullServerUrl();
  const url = makeUrl(urlPart, service.host, service._protocol);
  const method = "GET";
  const timeout = service.maxOperationRetryTime;
  const requestInfo = new RequestInfo(url, method, downloadUrlHandler(service, mappings), timeout);
  requestInfo.errorHandler = objectErrorHandler(location);
  return requestInfo;
}
function determineContentType_(metadata, blob) {
  return metadata && metadata["contentType"] || blob && blob.type() || "application/octet-stream";
}
function metadataForUpload_(location, blob, metadata) {
  const metadataClone = Object.assign({}, metadata);
  metadataClone["fullPath"] = location.path;
  metadataClone["size"] = blob.size();
  if (!metadataClone["contentType"]) {
    metadataClone["contentType"] = determineContentType_(null, blob);
  }
  return metadataClone;
}
function multipartUpload(service, location, mappings, blob, metadata) {
  const urlPart = location.bucketOnlyServerUrl();
  const headers = {
    "X-Goog-Upload-Protocol": "multipart"
  };
  function genBoundary() {
    let str = "";
    for (let i = 0; i < 2; i++) {
      str = str + Math.random().toString().slice(2);
    }
    return str;
  }
  const boundary = genBoundary();
  headers["Content-Type"] = "multipart/related; boundary=" + boundary;
  const metadata_ = metadataForUpload_(location, blob, metadata);
  const metadataString = toResourceString(metadata_, mappings);
  const preBlobPart = "--" + boundary + "\r\nContent-Type: application/json; charset=utf-8\r\n\r\n" + metadataString + "\r\n--" + boundary + "\r\nContent-Type: " + metadata_["contentType"] + "\r\n\r\n";
  const postBlobPart = "\r\n--" + boundary + "--";
  const body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);
  if (body === null) {
    throw cannotSliceBlob();
  }
  const urlParams = { name: metadata_["fullPath"] };
  const url = makeUrl(urlPart, service.host, service._protocol);
  const method = "POST";
  const timeout = service.maxUploadRetryTime;
  const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
  requestInfo.urlParams = urlParams;
  requestInfo.headers = headers;
  requestInfo.body = body.uploadData();
  requestInfo.errorHandler = sharedErrorHandler(location);
  return requestInfo;
}
function newTextConnection() {
  return textFactoryOverride ? textFactoryOverride() : new FetchTextConnection();
}
function newFetch(url, method, isUsingEmulator, headers, body) {
  const fetchArgs = {
    method,
    headers: headers || {},
    body
  };
  if (isCloudWorkstation(url) && isUsingEmulator) {
    fetchArgs.credentials = "include";
  }
  return fetch(url, fetchArgs);
}
function uploadBytes$1(ref2, data, metadata) {
  ref2._throwIfRoot("uploadBytes");
  const requestInfo = multipartUpload(ref2.storage, ref2._location, getMappings(), new FbsBlob(data, true), metadata);
  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection).then((finalMetadata) => {
    return {
      metadata: finalMetadata,
      ref: ref2
    };
  });
}
function getDownloadURL$1(ref2) {
  ref2._throwIfRoot("getDownloadURL");
  const requestInfo = getDownloadUrl(ref2.storage, ref2._location, getMappings());
  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection).then((url) => {
    if (url === null) {
      throw noDownloadURL();
    }
    return url;
  });
}
function _getChild$1(ref2, childPath) {
  const newPath = child(ref2._location.path, childPath);
  const location = new Location(ref2._location.bucket, newPath);
  return new Reference(ref2.storage, location);
}
function isUrl(path) {
  return /^[A-Za-z]+:\/\//.test(path);
}
function refFromURL(service, url) {
  return new Reference(service, url);
}
function refFromPath(ref2, path) {
  if (ref2 instanceof FirebaseStorageImpl) {
    const service = ref2;
    if (service._bucket == null) {
      throw noDefaultBucket();
    }
    const reference = new Reference(service, service._bucket);
    if (path != null) {
      return refFromPath(reference, path);
    } else {
      return reference;
    }
  } else {
    if (path !== void 0) {
      return _getChild$1(ref2, path);
    } else {
      return ref2;
    }
  }
}
function ref$1(serviceOrRef, pathOrUrl) {
  if (pathOrUrl && isUrl(pathOrUrl)) {
    if (serviceOrRef instanceof FirebaseStorageImpl) {
      return refFromURL(serviceOrRef, pathOrUrl);
    } else {
      throw invalidArgument("To use ref(service, url), the first argument must be a Storage instance.");
    }
  } else {
    return refFromPath(serviceOrRef, pathOrUrl);
  }
}
function extractBucket(host, config) {
  const bucketString = config?.[CONFIG_STORAGE_BUCKET_KEY];
  if (bucketString == null) {
    return null;
  }
  return Location.makeFromBucketSpec(bucketString, host);
}
function connectStorageEmulator$1(storage2, host, port, options = {}) {
  storage2.host = `${host}:${port}`;
  const useSsl = isCloudWorkstation(host);
  if (useSsl) {
    void pingServer(`https://${storage2.host}/b`);
    updateEmulatorBanner("Storage", true);
  }
  storage2._isUsingEmulator = true;
  storage2._protocol = useSsl ? "https" : "http";
  const { mockUserToken } = options;
  if (mockUserToken) {
    storage2._overrideAuthToken = typeof mockUserToken === "string" ? mockUserToken : createMockUserToken(mockUserToken, storage2.app.options.projectId);
  }
}
function uploadBytes(ref2, data, metadata) {
  ref2 = getModularInstance(ref2);
  return uploadBytes$1(ref2, data, metadata);
}
function getDownloadURL(ref2) {
  ref2 = getModularInstance(ref2);
  return getDownloadURL$1(ref2);
}
function ref(serviceOrRef, pathOrUrl) {
  serviceOrRef = getModularInstance(serviceOrRef);
  return ref$1(serviceOrRef, pathOrUrl);
}
function getStorage(app2 = getApp(), bucketUrl) {
  app2 = getModularInstance(app2);
  const storageProvider = _getProvider(app2, STORAGE_TYPE);
  const storageInstance = storageProvider.getImmediate({
    identifier: bucketUrl
  });
  const emulator = getDefaultEmulatorHostnameAndPort("storage");
  if (emulator) {
    connectStorageEmulator(storageInstance, ...emulator);
  }
  return storageInstance;
}
function connectStorageEmulator(storage2, host, port, options = {}) {
  connectStorageEmulator$1(storage2, host, port, options);
}
function factory(container, { instanceIdentifier: url }) {
  const app2 = container.getProvider("app").getImmediate();
  const authProvider = container.getProvider("auth-internal");
  const appCheckProvider = container.getProvider("app-check-internal");
  return new FirebaseStorageImpl(app2, authProvider, appCheckProvider, url, SDK_VERSION);
}
function registerStorage() {
  _registerComponent(new Component(
    STORAGE_TYPE,
    factory,
    "PUBLIC"
    /* ComponentType.PUBLIC */
  ).setMultipleInstances(true));
  registerVersion(name5, version5);
}
var DEFAULT_HOST, CONFIG_STORAGE_BUCKET_KEY, DEFAULT_MAX_OPERATION_RETRY_TIME, DEFAULT_MAX_UPLOAD_RETRY_TIME, StorageError, StorageErrorCode, Location, FailRequest, ErrorCode, NetworkRequest, RequestEndStatus, StringFormat, StringData, DataURLParts, FbsBlob, Mapping, mappings_, RequestInfo, RESUMABLE_UPLOAD_CHUNK_SIZE, textFactoryOverride, FetchConnection, FetchTextConnection, Reference, FirebaseStorageImpl, name5, version5, STORAGE_TYPE;
var init_index_node_esm2 = __esm({
  "node_modules/@firebase/storage/dist/node-esm/index.node.esm.js"() {
    init_index_esm3();
    init_index_node_esm();
    init_index_esm();
    DEFAULT_HOST = "firebasestorage.googleapis.com";
    CONFIG_STORAGE_BUCKET_KEY = "storageBucket";
    DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1e3;
    DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1e3;
    StorageError = class _StorageError extends FirebaseError {
      /**
       * @param code - A `StorageErrorCode` string to be prefixed with 'storage/' and
       *  added to the end of the message.
       * @param message  - Error message.
       * @param status_ - Corresponding HTTP Status Code
       */
      constructor(code, message, status_ = 0) {
        super(prependCode(code), `Firebase Storage: ${message} (${prependCode(code)})`);
        this.status_ = status_;
        this.customData = { serverResponse: null };
        this._baseMessage = this.message;
        Object.setPrototypeOf(this, _StorageError.prototype);
      }
      get status() {
        return this.status_;
      }
      set status(status) {
        this.status_ = status;
      }
      /**
       * Compares a `StorageErrorCode` against this error's code, filtering out the prefix.
       */
      _codeEquals(code) {
        return prependCode(code) === this.code;
      }
      /**
       * Optional response message that was added by the server.
       */
      get serverResponse() {
        return this.customData.serverResponse;
      }
      set serverResponse(serverResponse) {
        this.customData.serverResponse = serverResponse;
        if (this.customData.serverResponse) {
          this.message = `${this._baseMessage}
${this.customData.serverResponse}`;
        } else {
          this.message = this._baseMessage;
        }
      }
    };
    (function(StorageErrorCode2) {
      StorageErrorCode2["UNKNOWN"] = "unknown";
      StorageErrorCode2["OBJECT_NOT_FOUND"] = "object-not-found";
      StorageErrorCode2["BUCKET_NOT_FOUND"] = "bucket-not-found";
      StorageErrorCode2["PROJECT_NOT_FOUND"] = "project-not-found";
      StorageErrorCode2["QUOTA_EXCEEDED"] = "quota-exceeded";
      StorageErrorCode2["UNAUTHENTICATED"] = "unauthenticated";
      StorageErrorCode2["UNAUTHORIZED"] = "unauthorized";
      StorageErrorCode2["UNAUTHORIZED_APP"] = "unauthorized-app";
      StorageErrorCode2["RETRY_LIMIT_EXCEEDED"] = "retry-limit-exceeded";
      StorageErrorCode2["INVALID_CHECKSUM"] = "invalid-checksum";
      StorageErrorCode2["CANCELED"] = "canceled";
      StorageErrorCode2["INVALID_EVENT_NAME"] = "invalid-event-name";
      StorageErrorCode2["INVALID_URL"] = "invalid-url";
      StorageErrorCode2["INVALID_DEFAULT_BUCKET"] = "invalid-default-bucket";
      StorageErrorCode2["NO_DEFAULT_BUCKET"] = "no-default-bucket";
      StorageErrorCode2["CANNOT_SLICE_BLOB"] = "cannot-slice-blob";
      StorageErrorCode2["SERVER_FILE_WRONG_SIZE"] = "server-file-wrong-size";
      StorageErrorCode2["NO_DOWNLOAD_URL"] = "no-download-url";
      StorageErrorCode2["INVALID_ARGUMENT"] = "invalid-argument";
      StorageErrorCode2["INVALID_ARGUMENT_COUNT"] = "invalid-argument-count";
      StorageErrorCode2["APP_DELETED"] = "app-deleted";
      StorageErrorCode2["INVALID_ROOT_OPERATION"] = "invalid-root-operation";
      StorageErrorCode2["INVALID_FORMAT"] = "invalid-format";
      StorageErrorCode2["INTERNAL_ERROR"] = "internal-error";
      StorageErrorCode2["UNSUPPORTED_ENVIRONMENT"] = "unsupported-environment";
    })(StorageErrorCode || (StorageErrorCode = {}));
    Location = class _Location {
      constructor(bucket, path) {
        this.bucket = bucket;
        this.path_ = path;
      }
      get path() {
        return this.path_;
      }
      get isRoot() {
        return this.path.length === 0;
      }
      fullServerUrl() {
        const encode2 = encodeURIComponent;
        return "/b/" + encode2(this.bucket) + "/o/" + encode2(this.path);
      }
      bucketOnlyServerUrl() {
        const encode2 = encodeURIComponent;
        return "/b/" + encode2(this.bucket) + "/o";
      }
      static makeFromBucketSpec(bucketString, host) {
        let bucketLocation;
        try {
          bucketLocation = _Location.makeFromUrl(bucketString, host);
        } catch (e) {
          return new _Location(bucketString, "");
        }
        if (bucketLocation.path === "") {
          return bucketLocation;
        } else {
          throw invalidDefaultBucket(bucketString);
        }
      }
      static makeFromUrl(url, host) {
        let location = null;
        const bucketDomain = "([A-Za-z0-9.\\-_]+)";
        function gsModify(loc) {
          if (loc.path.charAt(loc.path.length - 1) === "/") {
            loc.path_ = loc.path_.slice(0, -1);
          }
        }
        const gsPath = "(/(.*))?$";
        const gsRegex = new RegExp("^gs://" + bucketDomain + gsPath, "i");
        const gsIndices = { bucket: 1, path: 3 };
        function httpModify(loc) {
          loc.path_ = decodeURIComponent(loc.path);
        }
        const version6 = "v[A-Za-z0-9_]+";
        const firebaseStorageHost = host.replace(/[.]/g, "\\.");
        const firebaseStoragePath = "(/([^?#]*).*)?$";
        const firebaseStorageRegExp = new RegExp(`^https?://${firebaseStorageHost}/${version6}/b/${bucketDomain}/o${firebaseStoragePath}`, "i");
        const firebaseStorageIndices = { bucket: 1, path: 3 };
        const cloudStorageHost = host === DEFAULT_HOST ? "(?:storage.googleapis.com|storage.cloud.google.com)" : host;
        const cloudStoragePath = "([^?#]*)";
        const cloudStorageRegExp = new RegExp(`^https?://${cloudStorageHost}/${bucketDomain}/${cloudStoragePath}`, "i");
        const cloudStorageIndices = { bucket: 1, path: 2 };
        const groups = [
          { regex: gsRegex, indices: gsIndices, postModify: gsModify },
          {
            regex: firebaseStorageRegExp,
            indices: firebaseStorageIndices,
            postModify: httpModify
          },
          {
            regex: cloudStorageRegExp,
            indices: cloudStorageIndices,
            postModify: httpModify
          }
        ];
        for (let i = 0; i < groups.length; i++) {
          const group = groups[i];
          const captures = group.regex.exec(url);
          if (captures) {
            const bucketValue = captures[group.indices.bucket];
            let pathValue = captures[group.indices.path];
            if (!pathValue) {
              pathValue = "";
            }
            location = new _Location(bucketValue, pathValue);
            group.postModify(location);
            break;
          }
        }
        if (location == null) {
          throw invalidUrl(url);
        }
        return location;
      }
    };
    FailRequest = class {
      constructor(error) {
        this.promise_ = Promise.reject(error);
      }
      /** @inheritDoc */
      getPromise() {
        return this.promise_;
      }
      /** @inheritDoc */
      cancel(_appDelete = false) {
      }
    };
    (function(ErrorCode2) {
      ErrorCode2[ErrorCode2["NO_ERROR"] = 0] = "NO_ERROR";
      ErrorCode2[ErrorCode2["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
      ErrorCode2[ErrorCode2["ABORT"] = 2] = "ABORT";
    })(ErrorCode || (ErrorCode = {}));
    NetworkRequest = class {
      constructor(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, connectionFactory_, retry = true, isUsingEmulator = false) {
        this.url_ = url_;
        this.method_ = method_;
        this.headers_ = headers_;
        this.body_ = body_;
        this.successCodes_ = successCodes_;
        this.additionalRetryCodes_ = additionalRetryCodes_;
        this.callback_ = callback_;
        this.errorCallback_ = errorCallback_;
        this.timeout_ = timeout_;
        this.progressCallback_ = progressCallback_;
        this.connectionFactory_ = connectionFactory_;
        this.retry = retry;
        this.isUsingEmulator = isUsingEmulator;
        this.pendingConnection_ = null;
        this.backoffId_ = null;
        this.canceled_ = false;
        this.appDelete_ = false;
        this.promise_ = new Promise((resolve, reject) => {
          this.resolve_ = resolve;
          this.reject_ = reject;
          this.start_();
        });
      }
      /**
       * Actually starts the retry loop.
       */
      start_() {
        const doTheRequest = (backoffCallback, canceled2) => {
          if (canceled2) {
            backoffCallback(false, new RequestEndStatus(false, null, true));
            return;
          }
          const connection = this.connectionFactory_();
          this.pendingConnection_ = connection;
          const progressListener = (progressEvent) => {
            const loaded = progressEvent.loaded;
            const total = progressEvent.lengthComputable ? progressEvent.total : -1;
            if (this.progressCallback_ !== null) {
              this.progressCallback_(loaded, total);
            }
          };
          if (this.progressCallback_ !== null) {
            connection.addUploadProgressListener(progressListener);
          }
          connection.send(this.url_, this.method_, this.isUsingEmulator, this.body_, this.headers_).then(() => {
            if (this.progressCallback_ !== null) {
              connection.removeUploadProgressListener(progressListener);
            }
            this.pendingConnection_ = null;
            const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
            const status = connection.getStatus();
            if (!hitServer || isRetryStatusCode(status, this.additionalRetryCodes_) && this.retry) {
              const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
              backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
              return;
            }
            const successCode = this.successCodes_.indexOf(status) !== -1;
            backoffCallback(true, new RequestEndStatus(successCode, connection));
          });
        };
        const backoffDone = (requestWentThrough, status) => {
          const resolve = this.resolve_;
          const reject = this.reject_;
          const connection = status.connection;
          if (status.wasSuccessCode) {
            try {
              const result = this.callback_(connection, connection.getResponse());
              if (isJustDef(result)) {
                resolve(result);
              } else {
                resolve();
              }
            } catch (e) {
              reject(e);
            }
          } else {
            if (connection !== null) {
              const err = unknown();
              err.serverResponse = connection.getErrorText();
              if (this.errorCallback_) {
                reject(this.errorCallback_(connection, err));
              } else {
                reject(err);
              }
            } else {
              if (status.canceled) {
                const err = this.appDelete_ ? appDeleted() : canceled();
                reject(err);
              } else {
                const err = retryLimitExceeded();
                reject(err);
              }
            }
          }
        };
        if (this.canceled_) {
          backoffDone(false, new RequestEndStatus(false, null, true));
        } else {
          this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_);
        }
      }
      /** @inheritDoc */
      getPromise() {
        return this.promise_;
      }
      /** @inheritDoc */
      cancel(appDelete) {
        this.canceled_ = true;
        this.appDelete_ = appDelete || false;
        if (this.backoffId_ !== null) {
          stop(this.backoffId_);
        }
        if (this.pendingConnection_ !== null) {
          this.pendingConnection_.abort();
        }
      }
    };
    RequestEndStatus = class {
      constructor(wasSuccessCode, connection, canceled2) {
        this.wasSuccessCode = wasSuccessCode;
        this.connection = connection;
        this.canceled = !!canceled2;
      }
    };
    StringFormat = {
      /**
       * Indicates the string should be interpreted "raw", that is, as normal text.
       * The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte
       * sequence.
       * Example: The string 'Hello! \\ud83d\\ude0a' becomes the byte sequence
       * 48 65 6c 6c 6f 21 20 f0 9f 98 8a
       */
      RAW: "raw",
      /**
       * Indicates the string should be interpreted as base64-encoded data.
       * Padding characters (trailing '='s) are optional.
       * Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence
       * ad 69 8e fb e1 3a b7 bf eb 97
       */
      BASE64: "base64",
      /**
       * Indicates the string should be interpreted as base64url-encoded data.
       * Padding characters (trailing '='s) are optional.
       * Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence
       * ad 69 8e fb e1 3a b7 bf eb 97
       */
      BASE64URL: "base64url",
      /**
       * Indicates the string is a data URL, such as one obtained from
       * canvas.toDataURL().
       * Example: the string 'data:application/octet-stream;base64,aaaa'
       * becomes the byte sequence
       * 69 a6 9a
       * (the content-type "application/octet-stream" is also applied, but can
       * be overridden in the metadata object).
       */
      DATA_URL: "data_url"
    };
    StringData = class {
      constructor(data, contentType) {
        this.data = data;
        this.contentType = contentType || null;
      }
    };
    DataURLParts = class {
      constructor(dataURL) {
        this.base64 = false;
        this.contentType = null;
        const matches = dataURL.match(/^data:([^,]+)?,/);
        if (matches === null) {
          throw invalidFormat(StringFormat.DATA_URL, "Must be formatted 'data:[<mediatype>][;base64],<data>");
        }
        const middle = matches[1] || null;
        if (middle != null) {
          this.base64 = endsWith(middle, ";base64");
          this.contentType = this.base64 ? middle.substring(0, middle.length - ";base64".length) : middle;
        }
        this.rest = dataURL.substring(dataURL.indexOf(",") + 1);
      }
    };
    FbsBlob = class _FbsBlob {
      constructor(data, elideCopy) {
        let size = 0;
        let blobType = "";
        if (isNativeBlob(data)) {
          this.data_ = data;
          size = data.size;
          blobType = data.type;
        } else if (data instanceof ArrayBuffer) {
          if (elideCopy) {
            this.data_ = new Uint8Array(data);
          } else {
            this.data_ = new Uint8Array(data.byteLength);
            this.data_.set(new Uint8Array(data));
          }
          size = this.data_.length;
        } else if (data instanceof Uint8Array) {
          if (elideCopy) {
            this.data_ = data;
          } else {
            this.data_ = new Uint8Array(data.length);
            this.data_.set(data);
          }
          size = data.length;
        }
        this.size_ = size;
        this.type_ = blobType;
      }
      size() {
        return this.size_;
      }
      type() {
        return this.type_;
      }
      slice(startByte, endByte) {
        if (isNativeBlob(this.data_)) {
          const realBlob = this.data_;
          const sliced = sliceBlob(realBlob, startByte, endByte);
          if (sliced === null) {
            return null;
          }
          return new _FbsBlob(sliced);
        } else {
          const slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);
          return new _FbsBlob(slice, true);
        }
      }
      static getBlob(...args) {
        if (isNativeBlobDefined()) {
          const blobby = args.map((val) => {
            if (val instanceof _FbsBlob) {
              return val.data_;
            } else {
              return val;
            }
          });
          return new _FbsBlob(getBlob$1.apply(null, blobby));
        } else {
          const uint8Arrays = args.map((val) => {
            if (isString(val)) {
              return dataFromString(StringFormat.RAW, val).data;
            } else {
              return val.data_;
            }
          });
          let finalLength = 0;
          uint8Arrays.forEach((array) => {
            finalLength += array.byteLength;
          });
          const merged = new Uint8Array(finalLength);
          let index = 0;
          uint8Arrays.forEach((array) => {
            for (let i = 0; i < array.length; i++) {
              merged[index++] = array[i];
            }
          });
          return new _FbsBlob(merged, true);
        }
      }
      uploadData() {
        return this.data_;
      }
    };
    Mapping = class {
      constructor(server, local, writable, xform) {
        this.server = server;
        this.local = local || server;
        this.writable = !!writable;
        this.xform = xform || noXform_;
      }
    };
    mappings_ = null;
    RequestInfo = class {
      constructor(url, method, handler, timeout) {
        this.url = url;
        this.method = method;
        this.handler = handler;
        this.timeout = timeout;
        this.urlParams = {};
        this.headers = {};
        this.body = null;
        this.errorHandler = null;
        this.progressCallback = null;
        this.successCodes = [200];
        this.additionalRetryCodes = [];
      }
    };
    RESUMABLE_UPLOAD_CHUNK_SIZE = 256 * 1024;
    textFactoryOverride = null;
    FetchConnection = class {
      constructor() {
        this.errorText_ = "";
        this.sent_ = false;
        this.errorCode_ = ErrorCode.NO_ERROR;
      }
      async send(url, method, isUsingEmulator, body, headers) {
        if (this.sent_) {
          throw internalError("cannot .send() more than once");
        }
        this.sent_ = true;
        try {
          const response = await newFetch(url, method, isUsingEmulator, headers, body);
          this.headers_ = response.headers;
          this.statusCode_ = response.status;
          this.errorCode_ = ErrorCode.NO_ERROR;
          this.body_ = await response.arrayBuffer();
        } catch (e) {
          this.errorText_ = e?.message;
          this.statusCode_ = 0;
          this.errorCode_ = ErrorCode.NETWORK_ERROR;
        }
      }
      getErrorCode() {
        if (this.errorCode_ === void 0) {
          throw internalError("cannot .getErrorCode() before receiving response");
        }
        return this.errorCode_;
      }
      getStatus() {
        if (this.statusCode_ === void 0) {
          throw internalError("cannot .getStatus() before receiving response");
        }
        return this.statusCode_;
      }
      getErrorText() {
        return this.errorText_;
      }
      abort() {
      }
      getResponseHeader(header) {
        if (!this.headers_) {
          throw internalError("cannot .getResponseHeader() before receiving response");
        }
        return this.headers_.get(header);
      }
      addUploadProgressListener(listener) {
      }
      removeUploadProgressListener(listener) {
      }
    };
    FetchTextConnection = class extends FetchConnection {
      getResponse() {
        if (!this.body_) {
          throw internalError("cannot .getResponse() before receiving response");
        }
        return Buffer.from(this.body_).toString("utf-8");
      }
    };
    Reference = class _Reference {
      constructor(_service, location) {
        this._service = _service;
        if (location instanceof Location) {
          this._location = location;
        } else {
          this._location = Location.makeFromUrl(location, _service.host);
        }
      }
      /**
       * Returns the URL for the bucket and path this object references,
       *     in the form gs://<bucket>/<object-path>
       * @override
       */
      toString() {
        return "gs://" + this._location.bucket + "/" + this._location.path;
      }
      _newRef(service, location) {
        return new _Reference(service, location);
      }
      /**
       * A reference to the root of this object's bucket.
       */
      get root() {
        const location = new Location(this._location.bucket, "");
        return this._newRef(this._service, location);
      }
      /**
       * The name of the bucket containing this reference's object.
       */
      get bucket() {
        return this._location.bucket;
      }
      /**
       * The full path of this object.
       */
      get fullPath() {
        return this._location.path;
      }
      /**
       * The short name of this object, which is the last component of the full path.
       * For example, if fullPath is 'full/path/image.png', name is 'image.png'.
       */
      get name() {
        return lastComponent(this._location.path);
      }
      /**
       * The `StorageService` instance this `StorageReference` is associated with.
       */
      get storage() {
        return this._service;
      }
      /**
       * A `StorageReference` pointing to the parent location of this `StorageReference`, or null if
       * this reference is the root.
       */
      get parent() {
        const newPath = parent(this._location.path);
        if (newPath === null) {
          return null;
        }
        const location = new Location(this._location.bucket, newPath);
        return new _Reference(this._service, location);
      }
      /**
       * Utility function to throw an error in methods that do not accept a root reference.
       */
      _throwIfRoot(name6) {
        if (this._location.path === "") {
          throw invalidRootOperation(name6);
        }
      }
    };
    FirebaseStorageImpl = class {
      constructor(app2, _authProvider, _appCheckProvider, _url, _firebaseVersion, _isUsingEmulator = false) {
        this.app = app2;
        this._authProvider = _authProvider;
        this._appCheckProvider = _appCheckProvider;
        this._url = _url;
        this._firebaseVersion = _firebaseVersion;
        this._isUsingEmulator = _isUsingEmulator;
        this._bucket = null;
        this._host = DEFAULT_HOST;
        this._protocol = "https";
        this._appId = null;
        this._deleted = false;
        this._maxOperationRetryTime = DEFAULT_MAX_OPERATION_RETRY_TIME;
        this._maxUploadRetryTime = DEFAULT_MAX_UPLOAD_RETRY_TIME;
        this._requests = /* @__PURE__ */ new Set();
        if (_url != null) {
          this._bucket = Location.makeFromBucketSpec(_url, this._host);
        } else {
          this._bucket = extractBucket(this._host, this.app.options);
        }
      }
      /**
       * The host string for this service, in the form of `host` or
       * `host:port`.
       */
      get host() {
        return this._host;
      }
      set host(host) {
        this._host = host;
        if (this._url != null) {
          this._bucket = Location.makeFromBucketSpec(this._url, host);
        } else {
          this._bucket = extractBucket(host, this.app.options);
        }
      }
      /**
       * The maximum time to retry uploads in milliseconds.
       */
      get maxUploadRetryTime() {
        return this._maxUploadRetryTime;
      }
      set maxUploadRetryTime(time) {
        validateNumber(
          "time",
          /* minValue=*/
          0,
          /* maxValue= */
          Number.POSITIVE_INFINITY,
          time
        );
        this._maxUploadRetryTime = time;
      }
      /**
       * The maximum time to retry operations other than uploads or downloads in
       * milliseconds.
       */
      get maxOperationRetryTime() {
        return this._maxOperationRetryTime;
      }
      set maxOperationRetryTime(time) {
        validateNumber(
          "time",
          /* minValue=*/
          0,
          /* maxValue= */
          Number.POSITIVE_INFINITY,
          time
        );
        this._maxOperationRetryTime = time;
      }
      async _getAuthToken() {
        if (this._overrideAuthToken) {
          return this._overrideAuthToken;
        }
        const auth2 = this._authProvider.getImmediate({ optional: true });
        if (auth2) {
          const tokenData = await auth2.getToken();
          if (tokenData !== null) {
            return tokenData.accessToken;
          }
        }
        return null;
      }
      async _getAppCheckToken() {
        if (_isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {
          return this.app.settings.appCheckToken;
        }
        const appCheck = this._appCheckProvider.getImmediate({ optional: true });
        if (appCheck) {
          const result = await appCheck.getToken();
          return result.token;
        }
        return null;
      }
      /**
       * Stop running requests and prevent more from being created.
       */
      _delete() {
        if (!this._deleted) {
          this._deleted = true;
          this._requests.forEach((request) => request.cancel());
          this._requests.clear();
        }
        return Promise.resolve();
      }
      /**
       * Returns a new firebaseStorage.Reference object referencing this StorageService
       * at the given Location.
       */
      _makeStorageReference(loc) {
        return new Reference(this, loc);
      }
      /**
       * @param requestInfo - HTTP RequestInfo object
       * @param authToken - Firebase auth token
       */
      _makeRequest(requestInfo, requestFactory, authToken, appCheckToken, retry = true) {
        if (!this._deleted) {
          const request = makeRequest(requestInfo, this._appId, authToken, appCheckToken, requestFactory, this._firebaseVersion, retry, this._isUsingEmulator);
          this._requests.add(request);
          request.getPromise().then(() => this._requests.delete(request), () => this._requests.delete(request));
          return request;
        } else {
          return new FailRequest(appDeleted());
        }
      }
      async makeRequestWithTokens(requestInfo, requestFactory) {
        const [authToken, appCheckToken] = await Promise.all([
          this._getAuthToken(),
          this._getAppCheckToken()
        ]);
        return this._makeRequest(requestInfo, requestFactory, authToken, appCheckToken).getPromise();
      }
    };
    name5 = "@firebase/storage";
    version5 = "0.14.0";
    STORAGE_TYPE = "storage";
    registerStorage();
  }
});

// node_modules/firebase/storage/dist/index.mjs
var init_dist4 = __esm({
  "node_modules/firebase/storage/dist/index.mjs"() {
    init_index_node_esm2();
  }
});

// src/firebase-config.ts
var firebase_config_exports = {};
__export(firebase_config_exports, {
  app: () => app,
  auth: () => auth,
  functions: () => functions,
  storage: () => storage
});
var firebaseConfig, app, auth, functions, storage;
var init_firebase_config = __esm({
  "src/firebase-config.ts"() {
    "use strict";
    init_dist();
    init_dist2();
    init_dist3();
    init_dist4();
    firebaseConfig = {
      apiKey: "AIzaSyD_qH-0Gr_pdmNLOQW5pea2BbiyHpxstN8",
      authDomain: "uuu-gl.firebaseapp.com",
      projectId: "uuu-gl",
      storageBucket: "uuu-gl.firebasestorage.app",
      messagingSenderId: "484571716021",
      appId: "1:484571716021:web:25ca37bf90f320cf07a1fc"
    };
    app = initializeApp(firebaseConfig);
    auth = getAuth(app);
    functions = getFunctions(app, "us-central1");
    storage = getStorage(app);
  }
});

// node_modules/@fingerprintjs/fingerprintjs/dist/fp.cjs.js
var require_fp_cjs = __commonJS({
  "node_modules/@fingerprintjs/fingerprintjs/dist/fp.cjs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var version6 = "5.0.1";
    function wait(durationMs, resolveWith) {
      return new Promise((resolve) => setTimeout(resolve, durationMs, resolveWith));
    }
    function releaseEventLoop() {
      return new Promise((resolve) => {
        const channel = new MessageChannel();
        channel.port1.onmessage = () => resolve();
        channel.port2.postMessage(null);
      });
    }
    function requestIdleCallbackIfAvailable(fallbackTimeout, deadlineTimeout = Infinity) {
      const { requestIdleCallback } = window;
      if (requestIdleCallback) {
        return new Promise((resolve) => requestIdleCallback.call(window, () => resolve(), { timeout: deadlineTimeout }));
      } else {
        return wait(Math.min(fallbackTimeout, deadlineTimeout));
      }
    }
    function isPromise(value) {
      return !!value && typeof value.then === "function";
    }
    function awaitIfAsync(action, callback) {
      try {
        const returnedValue = action();
        if (isPromise(returnedValue)) {
          returnedValue.then((result) => callback(true, result), (error) => callback(false, error));
        } else {
          callback(true, returnedValue);
        }
      } catch (error) {
        callback(false, error);
      }
    }
    async function mapWithBreaks(items, callback, loopReleaseInterval = 16) {
      const results = Array(items.length);
      let lastLoopReleaseTime = Date.now();
      for (let i = 0; i < items.length; ++i) {
        results[i] = callback(items[i], i);
        const now = Date.now();
        if (now >= lastLoopReleaseTime + loopReleaseInterval) {
          lastLoopReleaseTime = now;
          await releaseEventLoop();
        }
      }
      return results;
    }
    function suppressUnhandledRejectionWarning(promise) {
      promise.then(void 0, () => void 0);
      return promise;
    }
    function includes(haystack, needle) {
      for (let i = 0, l = haystack.length; i < l; ++i) {
        if (haystack[i] === needle) {
          return true;
        }
      }
      return false;
    }
    function excludes(haystack, needle) {
      return !includes(haystack, needle);
    }
    function toInt(value) {
      return parseInt(value);
    }
    function toFloat(value) {
      return parseFloat(value);
    }
    function replaceNaN(value, replacement) {
      return typeof value === "number" && isNaN(value) ? replacement : value;
    }
    function countTruthy(values) {
      return values.reduce((sum, value) => sum + (value ? 1 : 0), 0);
    }
    function round(value, base = 1) {
      if (Math.abs(base) >= 1) {
        return Math.round(value / base) * base;
      } else {
        const counterBase = 1 / base;
        return Math.round(value * counterBase) / counterBase;
      }
    }
    function parseSimpleCssSelector(selector) {
      var _a, _b;
      const errorMessage = `Unexpected syntax '${selector}'`;
      const tagMatch = /^\s*([a-z-]*)(.*)$/i.exec(selector);
      const tag = tagMatch[1] || void 0;
      const attributes = {};
      const partsRegex = /([.:#][\w-]+|\[.+?\])/gi;
      const addAttribute = (name6, value) => {
        attributes[name6] = attributes[name6] || [];
        attributes[name6].push(value);
      };
      for (; ; ) {
        const match = partsRegex.exec(tagMatch[2]);
        if (!match) {
          break;
        }
        const part = match[0];
        switch (part[0]) {
          case ".":
            addAttribute("class", part.slice(1));
            break;
          case "#":
            addAttribute("id", part.slice(1));
            break;
          case "[": {
            const attributeMatch = /^\[([\w-]+)([~|^$*]?=("(.*?)"|([\w-]+)))?(\s+[is])?\]$/.exec(part);
            if (attributeMatch) {
              addAttribute(attributeMatch[1], (_b = (_a = attributeMatch[4]) !== null && _a !== void 0 ? _a : attributeMatch[5]) !== null && _b !== void 0 ? _b : "");
            } else {
              throw new Error(errorMessage);
            }
            break;
          }
          default:
            throw new Error(errorMessage);
        }
      }
      return [tag, attributes];
    }
    function getUTF8Bytes(input) {
      const result = new Uint8Array(input.length);
      for (let i = 0; i < input.length; i++) {
        const charCode = input.charCodeAt(i);
        if (charCode > 127) {
          return new TextEncoder().encode(input);
        }
        result[i] = charCode;
      }
      return result;
    }
    function x64Add(m, n) {
      const m0 = m[0] >>> 16, m1 = m[0] & 65535, m2 = m[1] >>> 16, m3 = m[1] & 65535;
      const n0 = n[0] >>> 16, n1 = n[0] & 65535, n2 = n[1] >>> 16, n3 = n[1] & 65535;
      let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
      o3 += m3 + n3;
      o2 += o3 >>> 16;
      o3 &= 65535;
      o2 += m2 + n2;
      o1 += o2 >>> 16;
      o2 &= 65535;
      o1 += m1 + n1;
      o0 += o1 >>> 16;
      o1 &= 65535;
      o0 += m0 + n0;
      o0 &= 65535;
      m[0] = o0 << 16 | o1;
      m[1] = o2 << 16 | o3;
    }
    function x64Multiply(m, n) {
      const m0 = m[0] >>> 16, m1 = m[0] & 65535, m2 = m[1] >>> 16, m3 = m[1] & 65535;
      const n0 = n[0] >>> 16, n1 = n[0] & 65535, n2 = n[1] >>> 16, n3 = n[1] & 65535;
      let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
      o3 += m3 * n3;
      o2 += o3 >>> 16;
      o3 &= 65535;
      o2 += m2 * n3;
      o1 += o2 >>> 16;
      o2 &= 65535;
      o2 += m3 * n2;
      o1 += o2 >>> 16;
      o2 &= 65535;
      o1 += m1 * n3;
      o0 += o1 >>> 16;
      o1 &= 65535;
      o1 += m2 * n2;
      o0 += o1 >>> 16;
      o1 &= 65535;
      o1 += m3 * n1;
      o0 += o1 >>> 16;
      o1 &= 65535;
      o0 += m0 * n3 + m1 * n2 + m2 * n1 + m3 * n0;
      o0 &= 65535;
      m[0] = o0 << 16 | o1;
      m[1] = o2 << 16 | o3;
    }
    function x64Rotl(m, bits) {
      const m0 = m[0];
      bits %= 64;
      if (bits === 32) {
        m[0] = m[1];
        m[1] = m0;
      } else if (bits < 32) {
        m[0] = m0 << bits | m[1] >>> 32 - bits;
        m[1] = m[1] << bits | m0 >>> 32 - bits;
      } else {
        bits -= 32;
        m[0] = m[1] << bits | m0 >>> 32 - bits;
        m[1] = m0 << bits | m[1] >>> 32 - bits;
      }
    }
    function x64LeftShift(m, bits) {
      bits %= 64;
      if (bits === 0) {
        return;
      } else if (bits < 32) {
        m[0] = m[1] >>> 32 - bits;
        m[1] = m[1] << bits;
      } else {
        m[0] = m[1] << bits - 32;
        m[1] = 0;
      }
    }
    function x64Xor(m, n) {
      m[0] ^= n[0];
      m[1] ^= n[1];
    }
    var F1 = [4283543511, 3981806797];
    var F2 = [3301882366, 444984403];
    function x64Fmix(h) {
      const shifted = [0, h[0] >>> 1];
      x64Xor(h, shifted);
      x64Multiply(h, F1);
      shifted[1] = h[0] >>> 1;
      x64Xor(h, shifted);
      x64Multiply(h, F2);
      shifted[1] = h[0] >>> 1;
      x64Xor(h, shifted);
    }
    var C1 = [2277735313, 289559509];
    var C2 = [1291169091, 658871167];
    var M$1 = [0, 5];
    var N1 = [0, 1390208809];
    var N2 = [0, 944331445];
    function x64hash128(input, seed) {
      const key = getUTF8Bytes(input);
      seed = seed || 0;
      const length = [0, key.length];
      const remainder = length[1] % 16;
      const bytes = length[1] - remainder;
      const h1 = [0, seed];
      const h2 = [0, seed];
      const k1 = [0, 0];
      const k2 = [0, 0];
      let i;
      for (i = 0; i < bytes; i = i + 16) {
        k1[0] = key[i + 4] | key[i + 5] << 8 | key[i + 6] << 16 | key[i + 7] << 24;
        k1[1] = key[i] | key[i + 1] << 8 | key[i + 2] << 16 | key[i + 3] << 24;
        k2[0] = key[i + 12] | key[i + 13] << 8 | key[i + 14] << 16 | key[i + 15] << 24;
        k2[1] = key[i + 8] | key[i + 9] << 8 | key[i + 10] << 16 | key[i + 11] << 24;
        x64Multiply(k1, C1);
        x64Rotl(k1, 31);
        x64Multiply(k1, C2);
        x64Xor(h1, k1);
        x64Rotl(h1, 27);
        x64Add(h1, h2);
        x64Multiply(h1, M$1);
        x64Add(h1, N1);
        x64Multiply(k2, C2);
        x64Rotl(k2, 33);
        x64Multiply(k2, C1);
        x64Xor(h2, k2);
        x64Rotl(h2, 31);
        x64Add(h2, h1);
        x64Multiply(h2, M$1);
        x64Add(h2, N2);
      }
      k1[0] = 0;
      k1[1] = 0;
      k2[0] = 0;
      k2[1] = 0;
      const val = [0, 0];
      switch (remainder) {
        case 15:
          val[1] = key[i + 14];
          x64LeftShift(val, 48);
          x64Xor(k2, val);
        // fallthrough
        case 14:
          val[1] = key[i + 13];
          x64LeftShift(val, 40);
          x64Xor(k2, val);
        // fallthrough
        case 13:
          val[1] = key[i + 12];
          x64LeftShift(val, 32);
          x64Xor(k2, val);
        // fallthrough
        case 12:
          val[1] = key[i + 11];
          x64LeftShift(val, 24);
          x64Xor(k2, val);
        // fallthrough
        case 11:
          val[1] = key[i + 10];
          x64LeftShift(val, 16);
          x64Xor(k2, val);
        // fallthrough
        case 10:
          val[1] = key[i + 9];
          x64LeftShift(val, 8);
          x64Xor(k2, val);
        // fallthrough
        case 9:
          val[1] = key[i + 8];
          x64Xor(k2, val);
          x64Multiply(k2, C2);
          x64Rotl(k2, 33);
          x64Multiply(k2, C1);
          x64Xor(h2, k2);
        // fallthrough
        case 8:
          val[1] = key[i + 7];
          x64LeftShift(val, 56);
          x64Xor(k1, val);
        // fallthrough
        case 7:
          val[1] = key[i + 6];
          x64LeftShift(val, 48);
          x64Xor(k1, val);
        // fallthrough
        case 6:
          val[1] = key[i + 5];
          x64LeftShift(val, 40);
          x64Xor(k1, val);
        // fallthrough
        case 5:
          val[1] = key[i + 4];
          x64LeftShift(val, 32);
          x64Xor(k1, val);
        // fallthrough
        case 4:
          val[1] = key[i + 3];
          x64LeftShift(val, 24);
          x64Xor(k1, val);
        // fallthrough
        case 3:
          val[1] = key[i + 2];
          x64LeftShift(val, 16);
          x64Xor(k1, val);
        // fallthrough
        case 2:
          val[1] = key[i + 1];
          x64LeftShift(val, 8);
          x64Xor(k1, val);
        // fallthrough
        case 1:
          val[1] = key[i];
          x64Xor(k1, val);
          x64Multiply(k1, C1);
          x64Rotl(k1, 31);
          x64Multiply(k1, C2);
          x64Xor(h1, k1);
      }
      x64Xor(h1, length);
      x64Xor(h2, length);
      x64Add(h1, h2);
      x64Add(h2, h1);
      x64Fmix(h1);
      x64Fmix(h2);
      x64Add(h1, h2);
      x64Add(h2, h1);
      return ("00000000" + (h1[0] >>> 0).toString(16)).slice(-8) + ("00000000" + (h1[1] >>> 0).toString(16)).slice(-8) + ("00000000" + (h2[0] >>> 0).toString(16)).slice(-8) + ("00000000" + (h2[1] >>> 0).toString(16)).slice(-8);
    }
    function errorToObject(error) {
      var _a;
      return {
        name: error.name,
        message: error.message,
        stack: (_a = error.stack) === null || _a === void 0 ? void 0 : _a.split("\n"),
        // The fields are not enumerable, so TS is wrong saying that they will be overridden
        ...error
      };
    }
    function isFunctionNative(func) {
      return /^function\s.*?\{\s*\[native code]\s*}$/.test(String(func));
    }
    function isFinalResultLoaded(loadResult) {
      return typeof loadResult !== "function";
    }
    function loadSource(source, sourceOptions) {
      const sourceLoadPromise = suppressUnhandledRejectionWarning(new Promise((resolveLoad) => {
        const loadStartTime = Date.now();
        awaitIfAsync(source.bind(null, sourceOptions), (...loadArgs) => {
          const loadDuration = Date.now() - loadStartTime;
          if (!loadArgs[0]) {
            return resolveLoad(() => ({ error: loadArgs[1], duration: loadDuration }));
          }
          const loadResult = loadArgs[1];
          if (isFinalResultLoaded(loadResult)) {
            return resolveLoad(() => ({ value: loadResult, duration: loadDuration }));
          }
          resolveLoad(() => new Promise((resolveGet) => {
            const getStartTime = Date.now();
            awaitIfAsync(loadResult, (...getArgs) => {
              const duration = loadDuration + Date.now() - getStartTime;
              if (!getArgs[0]) {
                return resolveGet({ error: getArgs[1], duration });
              }
              resolveGet({ value: getArgs[1], duration });
            });
          }));
        });
      }));
      return function getComponent() {
        return sourceLoadPromise.then((finalizeSource) => finalizeSource());
      };
    }
    function loadSources(sources2, sourceOptions, excludeSources, loopReleaseInterval) {
      const includedSources = Object.keys(sources2).filter((sourceKey) => excludes(excludeSources, sourceKey));
      const sourceGettersPromise = suppressUnhandledRejectionWarning(mapWithBreaks(includedSources, (sourceKey) => loadSource(sources2[sourceKey], sourceOptions), loopReleaseInterval));
      return async function getComponents() {
        const sourceGetters = await sourceGettersPromise;
        const componentPromises = await mapWithBreaks(sourceGetters, (sourceGetter) => suppressUnhandledRejectionWarning(sourceGetter()), loopReleaseInterval);
        const componentArray = await Promise.all(componentPromises);
        const components = {};
        for (let index2 = 0; index2 < includedSources.length; ++index2) {
          components[includedSources[index2]] = componentArray[index2];
        }
        return components;
      };
    }
    function transformSource(source, transformValue) {
      const transformLoadResult = (loadResult) => {
        if (isFinalResultLoaded(loadResult)) {
          return transformValue(loadResult);
        }
        return () => {
          const getResult = loadResult();
          if (isPromise(getResult)) {
            return getResult.then(transformValue);
          }
          return transformValue(getResult);
        };
      };
      return (options) => {
        const loadResult = source(options);
        if (isPromise(loadResult)) {
          return loadResult.then(transformLoadResult);
        }
        return transformLoadResult(loadResult);
      };
    }
    function isTrident() {
      const w = window;
      const n = navigator;
      return countTruthy([
        "MSCSSMatrix" in w,
        "msSetImmediate" in w,
        "msIndexedDB" in w,
        "msMaxTouchPoints" in n,
        "msPointerEnabled" in n
      ]) >= 4;
    }
    function isEdgeHTML() {
      const w = window;
      const n = navigator;
      return countTruthy(["msWriteProfilerMark" in w, "MSStream" in w, "msLaunchUri" in n, "msSaveBlob" in n]) >= 3 && !isTrident();
    }
    function isChromium() {
      const w = window;
      const n = navigator;
      return countTruthy([
        "webkitPersistentStorage" in n,
        "webkitTemporaryStorage" in n,
        (n.vendor || "").indexOf("Google") === 0,
        "webkitResolveLocalFileSystemURL" in w,
        "BatteryManager" in w,
        "webkitMediaStream" in w,
        "webkitSpeechGrammar" in w
      ]) >= 5;
    }
    function isWebKit() {
      const w = window;
      const n = navigator;
      return countTruthy([
        "ApplePayError" in w,
        "CSSPrimitiveValue" in w,
        "Counter" in w,
        n.vendor.indexOf("Apple") === 0,
        "RGBColor" in w,
        "WebKitMediaKeys" in w
      ]) >= 4;
    }
    function isDesktopWebKit() {
      const w = window;
      const { HTMLElement, Document } = w;
      return countTruthy([
        "safari" in w,
        !("ongestureend" in w),
        !("TouchEvent" in w),
        !("orientation" in w),
        HTMLElement && !("autocapitalize" in HTMLElement.prototype),
        Document && "pointerLockElement" in Document.prototype
      ]) >= 4;
    }
    function isSafariWebKit() {
      const w = window;
      return (
        // Filters-out Chrome, Yandex, DuckDuckGo (macOS and iOS), Edge
        isFunctionNative(w.print) && // Doesn't work in Safari < 15.4
        String(w.browser) === "[object WebPageNamespace]"
      );
    }
    function isGecko() {
      var _a, _b;
      const w = window;
      return countTruthy([
        "buildID" in navigator,
        "MozAppearance" in ((_b = (_a = document.documentElement) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : {}),
        "onmozfullscreenchange" in w,
        "mozInnerScreenX" in w,
        "CSSMozDocumentRule" in w,
        "CanvasCaptureMediaStream" in w
      ]) >= 4;
    }
    function isChromium86OrNewer() {
      const w = window;
      return countTruthy([
        !("MediaSettingsRange" in w),
        "RTCEncodedAudioFrame" in w,
        "" + w.Intl === "[object Intl]",
        "" + w.Reflect === "[object Reflect]"
      ]) >= 3;
    }
    function isChromium122OrNewer() {
      const w = window;
      const { URLPattern } = w;
      return countTruthy([
        "union" in Set.prototype,
        "Iterator" in w,
        URLPattern && "hasRegExpGroups" in URLPattern.prototype,
        "RGB8" in WebGLRenderingContext.prototype
      ]) >= 3;
    }
    function isWebKit606OrNewer() {
      const w = window;
      return countTruthy([
        "DOMRectList" in w,
        "RTCPeerConnectionIceEvent" in w,
        "SVGGeometryElement" in w,
        "ontransitioncancel" in w
      ]) >= 3;
    }
    function isWebKit616OrNewer() {
      const w = window;
      const n = navigator;
      const { CSS, HTMLButtonElement } = w;
      return countTruthy([
        !("getStorageUpdates" in n),
        HTMLButtonElement && "popover" in HTMLButtonElement.prototype,
        "CSSCounterStyleRule" in w,
        CSS.supports("font-size-adjust: ex-height 0.5"),
        CSS.supports("text-transform: full-width")
      ]) >= 4;
    }
    function isIPad() {
      if (navigator.platform === "iPad") {
        return true;
      }
      const s = screen;
      const screenRatio = s.width / s.height;
      return countTruthy([
        // Since iOS 13. Doesn't work in Chrome on iPadOS <15, but works in desktop mode.
        "MediaSource" in window,
        // Since iOS 12. Doesn't work in Chrome on iPadOS.
        !!Element.prototype.webkitRequestFullscreen,
        // iPhone 4S that runs iOS 9 matches this, but it is not supported
        // Doesn't work in incognito mode of Safari ≥17 with split screen because of tracking prevention
        screenRatio > 0.65 && screenRatio < 1.53
      ]) >= 2;
    }
    function getFullscreenElement() {
      const d = document;
      return d.fullscreenElement || d.msFullscreenElement || d.mozFullScreenElement || d.webkitFullscreenElement || null;
    }
    function exitFullscreen() {
      const d = document;
      return (d.exitFullscreen || d.msExitFullscreen || d.mozCancelFullScreen || d.webkitExitFullscreen).call(d);
    }
    function isAndroid() {
      const isItChromium = isChromium();
      const isItGecko = isGecko();
      const w = window;
      const n = navigator;
      const c = "connection";
      if (isItChromium) {
        return countTruthy([
          !("SharedWorker" in w),
          // `typechange` is deprecated, but it's still present on Android (tested on Chrome Mobile 117)
          // Removal proposal https://bugs.chromium.org/p/chromium/issues/detail?id=699892
          // Note: this expression returns true on ChromeOS, so additional detectors are required to avoid false-positives
          n[c] && "ontypechange" in n[c],
          !("sinkId" in new Audio())
        ]) >= 2;
      } else if (isItGecko) {
        return countTruthy(["onorientationchange" in w, "orientation" in w, /android/i.test(n.appVersion)]) >= 2;
      } else {
        return false;
      }
    }
    function isSamsungInternet() {
      const n = navigator;
      const w = window;
      const audioPrototype = Audio.prototype;
      const { visualViewport } = w;
      return countTruthy([
        "srLatency" in audioPrototype,
        "srChannelCount" in audioPrototype,
        "devicePosture" in n,
        visualViewport && "segments" in visualViewport,
        "getTextInformation" in Image.prototype
        // Not available in Samsung Internet 21
      ]) >= 3;
    }
    function getAudioFingerprint() {
      if (doesBrowserPerformAntifingerprinting$1()) {
        return -4;
      }
      return getUnstableAudioFingerprint();
    }
    function getUnstableAudioFingerprint() {
      const w = window;
      const AudioContext2 = w.OfflineAudioContext || w.webkitOfflineAudioContext;
      if (!AudioContext2) {
        return -2;
      }
      if (doesBrowserSuspendAudioContext()) {
        return -1;
      }
      const hashFromIndex = 4500;
      const hashToIndex = 5e3;
      const context = new AudioContext2(1, hashToIndex, 44100);
      const oscillator = context.createOscillator();
      oscillator.type = "triangle";
      oscillator.frequency.value = 1e4;
      const compressor = context.createDynamicsCompressor();
      compressor.threshold.value = -50;
      compressor.knee.value = 40;
      compressor.ratio.value = 12;
      compressor.attack.value = 0;
      compressor.release.value = 0.25;
      oscillator.connect(compressor);
      compressor.connect(context.destination);
      oscillator.start(0);
      const [renderPromise, finishRendering] = startRenderingAudio(context);
      const fingerprintPromise = suppressUnhandledRejectionWarning(renderPromise.then((buffer) => getHash(buffer.getChannelData(0).subarray(hashFromIndex)), (error) => {
        if (error.name === "timeout" || error.name === "suspended") {
          return -3;
        }
        throw error;
      }));
      return () => {
        finishRendering();
        return fingerprintPromise;
      };
    }
    function doesBrowserSuspendAudioContext() {
      return isWebKit() && !isDesktopWebKit() && !isWebKit606OrNewer();
    }
    function doesBrowserPerformAntifingerprinting$1() {
      return (
        // Safari ≥17
        isWebKit() && isWebKit616OrNewer() && isSafariWebKit() || // Samsung Internet ≥26
        isChromium() && isSamsungInternet() && isChromium122OrNewer()
      );
    }
    function startRenderingAudio(context) {
      const renderTryMaxCount = 3;
      const renderRetryDelay = 500;
      const runningMaxAwaitTime = 500;
      const runningSufficientTime = 5e3;
      let finalize = () => void 0;
      const resultPromise = new Promise((resolve, reject) => {
        let isFinalized = false;
        let renderTryCount = 0;
        let startedRunningAt = 0;
        context.oncomplete = (event) => resolve(event.renderedBuffer);
        const startRunningTimeout = () => {
          setTimeout(() => reject(makeInnerError(
            "timeout"
            /* InnerErrorName.Timeout */
          )), Math.min(runningMaxAwaitTime, startedRunningAt + runningSufficientTime - Date.now()));
        };
        const tryRender = () => {
          try {
            const renderingPromise = context.startRendering();
            if (isPromise(renderingPromise)) {
              suppressUnhandledRejectionWarning(renderingPromise);
            }
            switch (context.state) {
              case "running":
                startedRunningAt = Date.now();
                if (isFinalized) {
                  startRunningTimeout();
                }
                break;
              // Sometimes the audio context doesn't start after calling `startRendering` (in addition to the cases where
              // audio context doesn't start at all). A known case is starting an audio context when the browser tab is in
              // background on iPhone. Retries usually help in this case.
              case "suspended":
                if (!document.hidden) {
                  renderTryCount++;
                }
                if (isFinalized && renderTryCount >= renderTryMaxCount) {
                  reject(makeInnerError(
                    "suspended"
                    /* InnerErrorName.Suspended */
                  ));
                } else {
                  setTimeout(tryRender, renderRetryDelay);
                }
                break;
            }
          } catch (error) {
            reject(error);
          }
        };
        tryRender();
        finalize = () => {
          if (!isFinalized) {
            isFinalized = true;
            if (startedRunningAt > 0) {
              startRunningTimeout();
            }
          }
        };
      });
      return [resultPromise, finalize];
    }
    function getHash(signal) {
      let hash = 0;
      for (let i = 0; i < signal.length; ++i) {
        hash += Math.abs(signal[i]);
      }
      return hash;
    }
    function makeInnerError(name6) {
      const error = new Error(name6);
      error.name = name6;
      return error;
    }
    async function withIframe(action, initialHtml, domPollInterval = 50) {
      var _a, _b, _c;
      const d = document;
      while (!d.body) {
        await wait(domPollInterval);
      }
      const iframe = d.createElement("iframe");
      try {
        await new Promise((_resolve, _reject) => {
          let isComplete = false;
          const resolve = () => {
            isComplete = true;
            _resolve();
          };
          const reject = (error) => {
            isComplete = true;
            _reject(error);
          };
          iframe.onload = resolve;
          iframe.onerror = reject;
          const { style } = iframe;
          style.setProperty("display", "block", "important");
          style.position = "absolute";
          style.top = "0";
          style.left = "0";
          style.visibility = "hidden";
          if (initialHtml && "srcdoc" in iframe) {
            iframe.srcdoc = initialHtml;
          } else {
            iframe.src = "about:blank";
          }
          d.body.appendChild(iframe);
          const checkReadyState = () => {
            var _a2, _b2;
            if (isComplete) {
              return;
            }
            if (((_b2 = (_a2 = iframe.contentWindow) === null || _a2 === void 0 ? void 0 : _a2.document) === null || _b2 === void 0 ? void 0 : _b2.readyState) === "complete") {
              resolve();
            } else {
              setTimeout(checkReadyState, 10);
            }
          };
          checkReadyState();
        });
        while (!((_b = (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.document) === null || _b === void 0 ? void 0 : _b.body)) {
          await wait(domPollInterval);
        }
        return await action(iframe, iframe.contentWindow);
      } finally {
        (_c = iframe.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(iframe);
      }
    }
    function selectorToElement(selector) {
      const [tag, attributes] = parseSimpleCssSelector(selector);
      const element = document.createElement(tag !== null && tag !== void 0 ? tag : "div");
      for (const name6 of Object.keys(attributes)) {
        const value = attributes[name6].join(" ");
        if (name6 === "style") {
          addStyleString(element.style, value);
        } else {
          element.setAttribute(name6, value);
        }
      }
      return element;
    }
    function addStyleString(style, source) {
      for (const property of source.split(";")) {
        const match = /^\s*([\w-]+)\s*:\s*(.+?)(\s*!([\w-]+))?\s*$/.exec(property);
        if (match) {
          const [, name6, value, , priority] = match;
          style.setProperty(name6, value, priority || "");
        }
      }
    }
    function isAnyParentCrossOrigin() {
      let currentWindow = window;
      for (; ; ) {
        const parentWindow = currentWindow.parent;
        if (!parentWindow || parentWindow === currentWindow) {
          return false;
        }
        try {
          if (parentWindow.location.origin !== currentWindow.location.origin) {
            return true;
          }
        } catch (error) {
          if (error instanceof Error && error.name === "SecurityError") {
            return true;
          }
          throw error;
        }
        currentWindow = parentWindow;
      }
    }
    var testString = "mmMwWLliI0O&1";
    var textSize = "48px";
    var baseFonts = ["monospace", "sans-serif", "serif"];
    var fontList = [
      // This is android-specific font from "Roboto" family
      "sans-serif-thin",
      "ARNO PRO",
      "Agency FB",
      "Arabic Typesetting",
      "Arial Unicode MS",
      "AvantGarde Bk BT",
      "BankGothic Md BT",
      "Batang",
      "Bitstream Vera Sans Mono",
      "Calibri",
      "Century",
      "Century Gothic",
      "Clarendon",
      "EUROSTILE",
      "Franklin Gothic",
      "Futura Bk BT",
      "Futura Md BT",
      "GOTHAM",
      "Gill Sans",
      "HELV",
      "Haettenschweiler",
      "Helvetica Neue",
      "Humanst521 BT",
      "Leelawadee",
      "Letter Gothic",
      "Levenim MT",
      "Lucida Bright",
      "Lucida Sans",
      "Menlo",
      "MS Mincho",
      "MS Outlook",
      "MS Reference Specialty",
      "MS UI Gothic",
      "MT Extra",
      "MYRIAD PRO",
      "Marlett",
      "Meiryo UI",
      "Microsoft Uighur",
      "Minion Pro",
      "Monotype Corsiva",
      "PMingLiU",
      "Pristina",
      "SCRIPTINA",
      "Segoe UI Light",
      "Serifa",
      "SimHei",
      "Small Fonts",
      "Staccato222 BT",
      "TRAJAN PRO",
      "Univers CE 55 Medium",
      "Vrinda",
      "ZWAdobeF"
    ];
    function getFonts() {
      return withIframe(async (_, { document: document2 }) => {
        const holder = document2.body;
        holder.style.fontSize = textSize;
        const spansContainer = document2.createElement("div");
        spansContainer.style.setProperty("visibility", "hidden", "important");
        const defaultWidth = {};
        const defaultHeight = {};
        const createSpan = (fontFamily) => {
          const span = document2.createElement("span");
          const { style } = span;
          style.position = "absolute";
          style.top = "0";
          style.left = "0";
          style.fontFamily = fontFamily;
          span.textContent = testString;
          spansContainer.appendChild(span);
          return span;
        };
        const createSpanWithFonts = (fontToDetect, baseFont) => {
          return createSpan(`'${fontToDetect}',${baseFont}`);
        };
        const initializeBaseFontsSpans = () => {
          return baseFonts.map(createSpan);
        };
        const initializeFontsSpans = () => {
          const spans = {};
          for (const font of fontList) {
            spans[font] = baseFonts.map((baseFont) => createSpanWithFonts(font, baseFont));
          }
          return spans;
        };
        const isFontAvailable = (fontSpans) => {
          return baseFonts.some((baseFont, baseFontIndex) => fontSpans[baseFontIndex].offsetWidth !== defaultWidth[baseFont] || fontSpans[baseFontIndex].offsetHeight !== defaultHeight[baseFont]);
        };
        const baseFontsSpans = initializeBaseFontsSpans();
        const fontsSpans = initializeFontsSpans();
        holder.appendChild(spansContainer);
        for (let index2 = 0; index2 < baseFonts.length; index2++) {
          defaultWidth[baseFonts[index2]] = baseFontsSpans[index2].offsetWidth;
          defaultHeight[baseFonts[index2]] = baseFontsSpans[index2].offsetHeight;
        }
        return fontList.filter((font) => isFontAvailable(fontsSpans[font]));
      });
    }
    function getPlugins() {
      const rawPlugins = navigator.plugins;
      if (!rawPlugins) {
        return void 0;
      }
      const plugins = [];
      for (let i = 0; i < rawPlugins.length; ++i) {
        const plugin = rawPlugins[i];
        if (!plugin) {
          continue;
        }
        const mimeTypes = [];
        for (let j = 0; j < plugin.length; ++j) {
          const mimeType = plugin[j];
          mimeTypes.push({
            type: mimeType.type,
            suffixes: mimeType.suffixes
          });
        }
        plugins.push({
          name: plugin.name,
          description: plugin.description,
          mimeTypes
        });
      }
      return plugins;
    }
    function getCanvasFingerprint() {
      return getUnstableCanvasFingerprint(doesBrowserPerformAntifingerprinting());
    }
    function getUnstableCanvasFingerprint(skipImages) {
      let winding = false;
      let geometry;
      let text;
      const [canvas, context] = makeCanvasContext();
      if (!isSupported(canvas, context)) {
        geometry = text = "unsupported";
      } else {
        winding = doesSupportWinding(context);
        if (skipImages) {
          geometry = text = "skipped";
        } else {
          [geometry, text] = renderImages(canvas, context);
        }
      }
      return { winding, geometry, text };
    }
    function makeCanvasContext() {
      const canvas = document.createElement("canvas");
      canvas.width = 1;
      canvas.height = 1;
      return [canvas, canvas.getContext("2d")];
    }
    function isSupported(canvas, context) {
      return !!(context && canvas.toDataURL);
    }
    function doesSupportWinding(context) {
      context.rect(0, 0, 10, 10);
      context.rect(2, 2, 6, 6);
      return !context.isPointInPath(5, 5, "evenodd");
    }
    function renderImages(canvas, context) {
      renderTextImage(canvas, context);
      const textImage1 = canvasToString(canvas);
      const textImage2 = canvasToString(canvas);
      if (textImage1 !== textImage2) {
        return [
          "unstable",
          "unstable"
          /* ImageStatus.Unstable */
        ];
      }
      renderGeometryImage(canvas, context);
      const geometryImage = canvasToString(canvas);
      return [geometryImage, textImage1];
    }
    function renderTextImage(canvas, context) {
      canvas.width = 240;
      canvas.height = 60;
      context.textBaseline = "alphabetic";
      context.fillStyle = "#f60";
      context.fillRect(100, 1, 62, 20);
      context.fillStyle = "#069";
      context.font = '11pt "Times New Roman"';
      const printedText = `Cwm fjordbank gly ${String.fromCharCode(55357, 56835)}`;
      context.fillText(printedText, 2, 15);
      context.fillStyle = "rgba(102, 204, 0, 0.2)";
      context.font = "18pt Arial";
      context.fillText(printedText, 4, 45);
    }
    function renderGeometryImage(canvas, context) {
      canvas.width = 122;
      canvas.height = 110;
      context.globalCompositeOperation = "multiply";
      for (const [color, x, y] of [
        ["#f2f", 40, 40],
        ["#2ff", 80, 40],
        ["#ff2", 60, 80]
      ]) {
        context.fillStyle = color;
        context.beginPath();
        context.arc(x, y, 40, 0, Math.PI * 2, true);
        context.closePath();
        context.fill();
      }
      context.fillStyle = "#f9c";
      context.arc(60, 60, 60, 0, Math.PI * 2, true);
      context.arc(60, 60, 20, 0, Math.PI * 2, true);
      context.fill("evenodd");
    }
    function canvasToString(canvas) {
      return canvas.toDataURL();
    }
    function doesBrowserPerformAntifingerprinting() {
      return isWebKit() && isWebKit616OrNewer() && isSafariWebKit();
    }
    function getTouchSupport() {
      const n = navigator;
      let maxTouchPoints = 0;
      let touchEvent;
      if (n.maxTouchPoints !== void 0) {
        maxTouchPoints = toInt(n.maxTouchPoints);
      } else if (n.msMaxTouchPoints !== void 0) {
        maxTouchPoints = n.msMaxTouchPoints;
      }
      try {
        document.createEvent("TouchEvent");
        touchEvent = true;
      } catch (_a) {
        touchEvent = false;
      }
      const touchStart = "ontouchstart" in window;
      return {
        maxTouchPoints,
        touchEvent,
        touchStart
      };
    }
    function getOsCpu() {
      return navigator.oscpu;
    }
    function getLanguages() {
      const n = navigator;
      const result = [];
      const language = n.language || n.userLanguage || n.browserLanguage || n.systemLanguage;
      if (language !== void 0) {
        result.push([language]);
      }
      if (Array.isArray(n.languages)) {
        if (!(isChromium() && isChromium86OrNewer())) {
          result.push(n.languages);
        }
      } else if (typeof n.languages === "string") {
        const languages = n.languages;
        if (languages) {
          result.push(languages.split(","));
        }
      }
      return result;
    }
    function getColorDepth() {
      return window.screen.colorDepth;
    }
    function getDeviceMemory() {
      return replaceNaN(toFloat(navigator.deviceMemory), void 0);
    }
    function getScreenResolution() {
      if (isWebKit() && isWebKit616OrNewer() && isSafariWebKit()) {
        return void 0;
      }
      return getUnstableScreenResolution();
    }
    function getUnstableScreenResolution() {
      const s = screen;
      const parseDimension = (value) => replaceNaN(toInt(value), null);
      const dimensions = [parseDimension(s.width), parseDimension(s.height)];
      dimensions.sort().reverse();
      return dimensions;
    }
    var screenFrameCheckInterval = 2500;
    var roundingPrecision = 10;
    var screenFrameBackup;
    var screenFrameSizeTimeoutId;
    function watchScreenFrame() {
      if (screenFrameSizeTimeoutId !== void 0) {
        return;
      }
      const checkScreenFrame = () => {
        const frameSize = getCurrentScreenFrame();
        if (isFrameSizeNull(frameSize)) {
          screenFrameSizeTimeoutId = setTimeout(checkScreenFrame, screenFrameCheckInterval);
        } else {
          screenFrameBackup = frameSize;
          screenFrameSizeTimeoutId = void 0;
        }
      };
      checkScreenFrame();
    }
    function getUnstableScreenFrame() {
      watchScreenFrame();
      return async () => {
        let frameSize = getCurrentScreenFrame();
        if (isFrameSizeNull(frameSize)) {
          if (screenFrameBackup) {
            return [...screenFrameBackup];
          }
          if (getFullscreenElement()) {
            await exitFullscreen();
            frameSize = getCurrentScreenFrame();
          }
        }
        if (!isFrameSizeNull(frameSize)) {
          screenFrameBackup = frameSize;
        }
        return frameSize;
      };
    }
    function getScreenFrame() {
      if (isWebKit() && isWebKit616OrNewer() && isSafariWebKit()) {
        return () => Promise.resolve(void 0);
      }
      const screenFrameGetter = getUnstableScreenFrame();
      return async () => {
        const frameSize = await screenFrameGetter();
        const processSize = (sideSize) => sideSize === null ? null : round(sideSize, roundingPrecision);
        return [processSize(frameSize[0]), processSize(frameSize[1]), processSize(frameSize[2]), processSize(frameSize[3])];
      };
    }
    function getCurrentScreenFrame() {
      const s = screen;
      return [
        replaceNaN(toFloat(s.availTop), null),
        replaceNaN(toFloat(s.width) - toFloat(s.availWidth) - replaceNaN(toFloat(s.availLeft), 0), null),
        replaceNaN(toFloat(s.height) - toFloat(s.availHeight) - replaceNaN(toFloat(s.availTop), 0), null),
        replaceNaN(toFloat(s.availLeft), null)
      ];
    }
    function isFrameSizeNull(frameSize) {
      for (let i = 0; i < 4; ++i) {
        if (frameSize[i]) {
          return false;
        }
      }
      return true;
    }
    function getHardwareConcurrency() {
      return replaceNaN(toInt(navigator.hardwareConcurrency), void 0);
    }
    function getTimezone() {
      var _a;
      const DateTimeFormat = (_a = window.Intl) === null || _a === void 0 ? void 0 : _a.DateTimeFormat;
      if (DateTimeFormat) {
        const timezone = new DateTimeFormat().resolvedOptions().timeZone;
        if (timezone) {
          return timezone;
        }
      }
      const offset = -getTimezoneOffset();
      return `UTC${offset >= 0 ? "+" : ""}${offset}`;
    }
    function getTimezoneOffset() {
      const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
      return Math.max(
        // `getTimezoneOffset` returns a number as a string in some unidentified cases
        toFloat(new Date(currentYear, 0, 1).getTimezoneOffset()),
        toFloat(new Date(currentYear, 6, 1).getTimezoneOffset())
      );
    }
    function getSessionStorage() {
      try {
        return !!window.sessionStorage;
      } catch (error) {
        return true;
      }
    }
    function getLocalStorage() {
      try {
        return !!window.localStorage;
      } catch (e) {
        return true;
      }
    }
    function getIndexedDB() {
      if (isTrident() || isEdgeHTML()) {
        return void 0;
      }
      try {
        return !!window.indexedDB;
      } catch (e) {
        return true;
      }
    }
    function getOpenDatabase() {
      return !!window.openDatabase;
    }
    function getCpuClass() {
      return navigator.cpuClass;
    }
    function getPlatform() {
      const { platform } = navigator;
      if (platform === "MacIntel") {
        if (isWebKit() && !isDesktopWebKit()) {
          return isIPad() ? "iPad" : "iPhone";
        }
      }
      return platform;
    }
    function getVendor() {
      return navigator.vendor || "";
    }
    function getVendorFlavors() {
      const flavors = [];
      for (const key of [
        // Blink and some browsers on iOS
        "chrome",
        // Safari on macOS
        "safari",
        // Chrome on iOS (checked in 85 on 13 and 87 on 14)
        "__crWeb",
        "__gCrWeb",
        // Yandex Browser on iOS, macOS and Android (checked in 21.2 on iOS 14, macOS and Android)
        "yandex",
        // Yandex Browser on iOS (checked in 21.2 on 14)
        "__yb",
        "__ybro",
        // Firefox on iOS (checked in 32 on 14)
        "__firefox__",
        // Edge on iOS (checked in 46 on 14)
        "__edgeTrackingPreventionStatistics",
        "webkit",
        // Opera Touch on iOS (checked in 2.6 on 14)
        "oprt",
        // Samsung Internet on Android (checked in 11.1)
        "samsungAr",
        // UC Browser on Android (checked in 12.10 and 13.0)
        "ucweb",
        "UCShellJava",
        // Puffin on Android (checked in 9.0)
        "puffinDevice"
        // UC on iOS and Opera on Android have no specific global variables
        // Edge for Android isn't checked
      ]) {
        const value = window[key];
        if (value && typeof value === "object") {
          flavors.push(key);
        }
      }
      return flavors.sort();
    }
    function areCookiesEnabled() {
      const d = document;
      try {
        d.cookie = "cookietest=1; SameSite=Strict;";
        const result = d.cookie.indexOf("cookietest=") !== -1;
        d.cookie = "cookietest=1; SameSite=Strict; expires=Thu, 01-Jan-1970 00:00:01 GMT";
        return result;
      } catch (e) {
        return false;
      }
    }
    function getFilters() {
      const fromB64 = atob;
      return {
        abpIndo: [
          "#Iklan-Melayang",
          "#Kolom-Iklan-728",
          "#SidebarIklan-wrapper",
          '[title="ALIENBOLA" i]',
          fromB64("I0JveC1CYW5uZXItYWRz")
        ],
        abpvn: [".quangcao", "#mobileCatfish", fromB64("LmNsb3NlLWFkcw=="), '[id^="bn_bottom_fixed_"]', "#pmadv"],
        adBlockFinland: [
          ".mainostila",
          fromB64("LnNwb25zb3JpdA=="),
          ".ylamainos",
          fromB64("YVtocmVmKj0iL2NsaWNrdGhyZ2guYXNwPyJd"),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9hcHAucmVhZHBlYWsuY29tL2FkcyJd")
        ],
        adBlockPersian: [
          "#navbar_notice_50",
          ".kadr",
          'TABLE[width="140px"]',
          "#divAgahi",
          fromB64("YVtocmVmXj0iaHR0cDovL2cxLnYuZndtcm0ubmV0L2FkLyJd")
        ],
        adBlockWarningRemoval: [
          "#adblock-honeypot",
          ".adblocker-root",
          ".wp_adblock_detect",
          fromB64("LmhlYWRlci1ibG9ja2VkLWFk"),
          fromB64("I2FkX2Jsb2NrZXI=")
        ],
        adGuardAnnoyances: [
          ".hs-sosyal",
          "#cookieconsentdiv",
          'div[class^="app_gdpr"]',
          ".as-oil",
          '[data-cypress="soft-push-notification-modal"]'
        ],
        adGuardBase: [
          ".BetterJsPopOverlay",
          fromB64("I2FkXzMwMFgyNTA="),
          fromB64("I2Jhbm5lcmZsb2F0MjI="),
          fromB64("I2NhbXBhaWduLWJhbm5lcg=="),
          fromB64("I0FkLUNvbnRlbnQ=")
        ],
        adGuardChinese: [
          fromB64("LlppX2FkX2FfSA=="),
          fromB64("YVtocmVmKj0iLmh0aGJldDM0LmNvbSJd"),
          "#widget-quan",
          fromB64("YVtocmVmKj0iLzg0OTkyMDIwLnh5eiJd"),
          fromB64("YVtocmVmKj0iLjE5NTZobC5jb20vIl0=")
        ],
        adGuardFrench: [
          "#pavePub",
          fromB64("LmFkLWRlc2t0b3AtcmVjdGFuZ2xl"),
          ".mobile_adhesion",
          ".widgetadv",
          fromB64("LmFkc19iYW4=")
        ],
        adGuardGerman: ['aside[data-portal-id="leaderboard"]'],
        adGuardJapanese: [
          "#kauli_yad_1",
          fromB64("YVtocmVmXj0iaHR0cDovL2FkMi50cmFmZmljZ2F0ZS5uZXQvIl0="),
          fromB64("Ll9wb3BJbl9pbmZpbml0ZV9hZA=="),
          fromB64("LmFkZ29vZ2xl"),
          fromB64("Ll9faXNib29zdFJldHVybkFk")
        ],
        adGuardMobile: [
          fromB64("YW1wLWF1dG8tYWRz"),
          fromB64("LmFtcF9hZA=="),
          'amp-embed[type="24smi"]',
          "#mgid_iframe1",
          fromB64("I2FkX2ludmlld19hcmVh")
        ],
        adGuardRussian: [
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9hZC5sZXRtZWFkcy5jb20vIl0="),
          fromB64("LnJlY2xhbWE="),
          'div[id^="smi2adblock"]',
          fromB64("ZGl2W2lkXj0iQWRGb3hfYmFubmVyXyJd"),
          "#psyduckpockeball"
        ],
        adGuardSocial: [
          fromB64("YVtocmVmXj0iLy93d3cuc3R1bWJsZXVwb24uY29tL3N1Ym1pdD91cmw9Il0="),
          fromB64("YVtocmVmXj0iLy90ZWxlZ3JhbS5tZS9zaGFyZS91cmw/Il0="),
          ".etsy-tweet",
          "#inlineShare",
          ".popup-social"
        ],
        adGuardSpanishPortuguese: ["#barraPublicidade", "#Publicidade", "#publiEspecial", "#queTooltip", ".cnt-publi"],
        adGuardTrackingProtection: [
          "#qoo-counter",
          fromB64("YVtocmVmXj0iaHR0cDovL2NsaWNrLmhvdGxvZy5ydS8iXQ=="),
          fromB64("YVtocmVmXj0iaHR0cDovL2hpdGNvdW50ZXIucnUvdG9wL3N0YXQucGhwIl0="),
          fromB64("YVtocmVmXj0iaHR0cDovL3RvcC5tYWlsLnJ1L2p1bXAiXQ=="),
          "#top100counter"
        ],
        adGuardTurkish: [
          "#backkapat",
          fromB64("I3Jla2xhbWk="),
          fromB64("YVtocmVmXj0iaHR0cDovL2Fkc2Vydi5vbnRlay5jb20udHIvIl0="),
          fromB64("YVtocmVmXj0iaHR0cDovL2l6bGVuemkuY29tL2NhbXBhaWduLyJd"),
          fromB64("YVtocmVmXj0iaHR0cDovL3d3dy5pbnN0YWxsYWRzLm5ldC8iXQ==")
        ],
        bulgarian: [fromB64("dGQjZnJlZW5ldF90YWJsZV9hZHM="), "#ea_intext_div", ".lapni-pop-over", "#xenium_hot_offers"],
        easyList: [
          ".yb-floorad",
          fromB64("LndpZGdldF9wb19hZHNfd2lkZ2V0"),
          fromB64("LnRyYWZmaWNqdW5reS1hZA=="),
          ".textad_headline",
          fromB64("LnNwb25zb3JlZC10ZXh0LWxpbmtz")
        ],
        easyListChina: [
          fromB64("LmFwcGd1aWRlLXdyYXBbb25jbGljayo9ImJjZWJvcy5jb20iXQ=="),
          fromB64("LmZyb250cGFnZUFkdk0="),
          "#taotaole",
          "#aafoot.top_box",
          ".cfa_popup"
        ],
        easyListCookie: [
          ".ezmob-footer",
          ".cc-CookieWarning",
          "[data-cookie-number]",
          fromB64("LmF3LWNvb2tpZS1iYW5uZXI="),
          ".sygnal24-gdpr-modal-wrap"
        ],
        easyListCzechSlovak: [
          "#onlajny-stickers",
          fromB64("I3Jla2xhbW5pLWJveA=="),
          fromB64("LnJla2xhbWEtbWVnYWJvYXJk"),
          ".sklik",
          fromB64("W2lkXj0ic2tsaWtSZWtsYW1hIl0=")
        ],
        easyListDutch: [
          fromB64("I2FkdmVydGVudGll"),
          fromB64("I3ZpcEFkbWFya3RCYW5uZXJCbG9jaw=="),
          ".adstekst",
          fromB64("YVtocmVmXj0iaHR0cHM6Ly94bHR1YmUubmwvY2xpY2svIl0="),
          "#semilo-lrectangle"
        ],
        easyListGermany: [
          "#SSpotIMPopSlider",
          fromB64("LnNwb25zb3JsaW5rZ3J1ZW4="),
          fromB64("I3dlcmJ1bmdza3k="),
          fromB64("I3Jla2xhbWUtcmVjaHRzLW1pdHRl"),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9iZDc0Mi5jb20vIl0=")
        ],
        easyListItaly: [
          fromB64("LmJveF9hZHZfYW5udW5jaQ=="),
          ".sb-box-pubbliredazionale",
          fromB64("YVtocmVmXj0iaHR0cDovL2FmZmlsaWF6aW9uaWFkcy5zbmFpLml0LyJd"),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9hZHNlcnZlci5odG1sLml0LyJd"),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9hZmZpbGlhemlvbmlhZHMuc25haS5pdC8iXQ==")
        ],
        easyListLithuania: [
          fromB64("LnJla2xhbW9zX3RhcnBhcw=="),
          fromB64("LnJla2xhbW9zX251b3JvZG9z"),
          fromB64("aW1nW2FsdD0iUmVrbGFtaW5pcyBza3lkZWxpcyJd"),
          fromB64("aW1nW2FsdD0iRGVkaWt1b3RpLmx0IHNlcnZlcmlhaSJd"),
          fromB64("aW1nW2FsdD0iSG9zdGluZ2FzIFNlcnZlcmlhaS5sdCJd")
        ],
        estonian: [fromB64("QVtocmVmKj0iaHR0cDovL3BheTRyZXN1bHRzMjQuZXUiXQ==")],
        fanboyAnnoyances: ["#ac-lre-player", ".navigate-to-top", "#subscribe_popup", ".newsletter_holder", "#back-top"],
        fanboyAntiFacebook: [".util-bar-module-firefly-visible"],
        fanboyEnhancedTrackers: [
          ".open.pushModal",
          "#issuem-leaky-paywall-articles-zero-remaining-nag",
          "#sovrn_container",
          'div[class$="-hide"][zoompage-fontsize][style="display: block;"]',
          ".BlockNag__Card"
        ],
        fanboySocial: ["#FollowUs", "#meteored_share", "#social_follow", ".article-sharer", ".community__social-desc"],
        frellwitSwedish: [
          fromB64("YVtocmVmKj0iY2FzaW5vcHJvLnNlIl1bdGFyZ2V0PSJfYmxhbmsiXQ=="),
          fromB64("YVtocmVmKj0iZG9rdG9yLXNlLm9uZWxpbmsubWUiXQ=="),
          "article.category-samarbete",
          fromB64("ZGl2LmhvbGlkQWRz"),
          "ul.adsmodern"
        ],
        greekAdBlock: [
          fromB64("QVtocmVmKj0iYWRtYW4ub3RlbmV0LmdyL2NsaWNrPyJd"),
          fromB64("QVtocmVmKj0iaHR0cDovL2F4aWFiYW5uZXJzLmV4b2R1cy5nci8iXQ=="),
          fromB64("QVtocmVmKj0iaHR0cDovL2ludGVyYWN0aXZlLmZvcnRobmV0LmdyL2NsaWNrPyJd"),
          "DIV.agores300",
          "TABLE.advright"
        ],
        hungarian: [
          "#cemp_doboz",
          ".optimonk-iframe-container",
          fromB64("LmFkX19tYWlu"),
          fromB64("W2NsYXNzKj0iR29vZ2xlQWRzIl0="),
          "#hirdetesek_box"
        ],
        iDontCareAboutCookies: [
          '.alert-info[data-block-track*="CookieNotice"]',
          ".ModuleTemplateCookieIndicator",
          ".o--cookies--container",
          "#cookies-policy-sticky",
          "#stickyCookieBar"
        ],
        icelandicAbp: [fromB64("QVtocmVmXj0iL2ZyYW1ld29yay9yZXNvdXJjZXMvZm9ybXMvYWRzLmFzcHgiXQ==")],
        latvian: [
          fromB64("YVtocmVmPSJodHRwOi8vd3d3LnNhbGlkemluaS5sdi8iXVtzdHlsZT0iZGlzcGxheTogYmxvY2s7IHdpZHRoOiAxMjBweDsgaGVpZ2h0OiA0MHB4OyBvdmVyZmxvdzogaGlkZGVuOyBwb3NpdGlvbjogcmVsYXRpdmU7Il0="),
          fromB64("YVtocmVmPSJodHRwOi8vd3d3LnNhbGlkemluaS5sdi8iXVtzdHlsZT0iZGlzcGxheTogYmxvY2s7IHdpZHRoOiA4OHB4OyBoZWlnaHQ6IDMxcHg7IG92ZXJmbG93OiBoaWRkZW47IHBvc2l0aW9uOiByZWxhdGl2ZTsiXQ==")
        ],
        listKr: [
          fromB64("YVtocmVmKj0iLy9hZC5wbGFuYnBsdXMuY28ua3IvIl0="),
          fromB64("I2xpdmVyZUFkV3JhcHBlcg=="),
          fromB64("YVtocmVmKj0iLy9hZHYuaW1hZHJlcC5jby5rci8iXQ=="),
          fromB64("aW5zLmZhc3R2aWV3LWFk"),
          ".revenue_unit_item.dable"
        ],
        listeAr: [
          fromB64("LmdlbWluaUxCMUFk"),
          ".right-and-left-sponsers",
          fromB64("YVtocmVmKj0iLmFmbGFtLmluZm8iXQ=="),
          fromB64("YVtocmVmKj0iYm9vcmFxLm9yZyJd"),
          fromB64("YVtocmVmKj0iZHViaXp6bGUuY29tL2FyLz91dG1fc291cmNlPSJd")
        ],
        listeFr: [
          fromB64("YVtocmVmXj0iaHR0cDovL3Byb21vLnZhZG9yLmNvbS8iXQ=="),
          fromB64("I2FkY29udGFpbmVyX3JlY2hlcmNoZQ=="),
          fromB64("YVtocmVmKj0id2Vib3JhbWEuZnIvZmNnaS1iaW4vIl0="),
          ".site-pub-interstitiel",
          'div[id^="crt-"][data-criteo-id]'
        ],
        officialPolish: [
          "#ceneo-placeholder-ceneo-12",
          fromB64("W2hyZWZePSJodHRwczovL2FmZi5zZW5kaHViLnBsLyJd"),
          fromB64("YVtocmVmXj0iaHR0cDovL2Fkdm1hbmFnZXIudGVjaGZ1bi5wbC9yZWRpcmVjdC8iXQ=="),
          fromB64("YVtocmVmXj0iaHR0cDovL3d3dy50cml6ZXIucGwvP3V0bV9zb3VyY2UiXQ=="),
          fromB64("ZGl2I3NrYXBpZWNfYWQ=")
        ],
        ro: [
          fromB64("YVtocmVmXj0iLy9hZmZ0cmsuYWx0ZXgucm8vQ291bnRlci9DbGljayJd"),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9ibGFja2ZyaWRheXNhbGVzLnJvL3Ryay9zaG9wLyJd"),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9ldmVudC4ycGVyZm9ybWFudC5jb20vZXZlbnRzL2NsaWNrIl0="),
          fromB64("YVtocmVmXj0iaHR0cHM6Ly9sLnByb2ZpdHNoYXJlLnJvLyJd"),
          'a[href^="/url/"]'
        ],
        ruAd: [
          fromB64("YVtocmVmKj0iLy9mZWJyYXJlLnJ1LyJd"),
          fromB64("YVtocmVmKj0iLy91dGltZy5ydS8iXQ=="),
          fromB64("YVtocmVmKj0iOi8vY2hpa2lkaWtpLnJ1Il0="),
          "#pgeldiz",
          ".yandex-rtb-block"
        ],
        thaiAds: [
          "a[href*=macau-uta-popup]",
          fromB64("I2Fkcy1nb29nbGUtbWlkZGxlX3JlY3RhbmdsZS1ncm91cA=="),
          fromB64("LmFkczMwMHM="),
          ".bumq",
          ".img-kosana"
        ],
        webAnnoyancesUltralist: [
          "#mod-social-share-2",
          "#social-tools",
          fromB64("LmN0cGwtZnVsbGJhbm5lcg=="),
          ".zergnet-recommend",
          ".yt.btn-link.btn-md.btn"
        ]
      };
    }
    async function getDomBlockers({ debug } = {}) {
      if (!isApplicable()) {
        return void 0;
      }
      const filters = getFilters();
      const filterNames = Object.keys(filters);
      const allSelectors = [].concat(...filterNames.map((filterName) => filters[filterName]));
      const blockedSelectors = await getBlockedSelectors(allSelectors);
      if (debug) {
        printDebug(filters, blockedSelectors);
      }
      const activeBlockers = filterNames.filter((filterName) => {
        const selectors = filters[filterName];
        const blockedCount = countTruthy(selectors.map((selector) => blockedSelectors[selector]));
        return blockedCount > selectors.length * 0.6;
      });
      activeBlockers.sort();
      return activeBlockers;
    }
    function isApplicable() {
      return isWebKit() || isAndroid();
    }
    async function getBlockedSelectors(selectors) {
      var _a;
      const d = document;
      const root = d.createElement("div");
      const elements = new Array(selectors.length);
      const blockedSelectors = {};
      forceShow(root);
      for (let i = 0; i < selectors.length; ++i) {
        const element = selectorToElement(selectors[i]);
        if (element.tagName === "DIALOG") {
          element.show();
        }
        const holder = d.createElement("div");
        forceShow(holder);
        holder.appendChild(element);
        root.appendChild(holder);
        elements[i] = element;
      }
      while (!d.body) {
        await wait(50);
      }
      d.body.appendChild(root);
      try {
        for (let i = 0; i < selectors.length; ++i) {
          if (!elements[i].offsetParent) {
            blockedSelectors[selectors[i]] = true;
          }
        }
      } finally {
        (_a = root.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(root);
      }
      return blockedSelectors;
    }
    function forceShow(element) {
      element.style.setProperty("visibility", "hidden", "important");
      element.style.setProperty("display", "block", "important");
    }
    function printDebug(filters, blockedSelectors) {
      let message = "DOM blockers debug:\n```";
      for (const filterName of Object.keys(filters)) {
        message += `
${filterName}:`;
        for (const selector of filters[filterName]) {
          message += `
  ${blockedSelectors[selector] ? "\u{1F6AB}" : "\u27A1\uFE0F"} ${selector}`;
        }
      }
      console.log(`${message}
\`\`\``);
    }
    function getColorGamut() {
      for (const gamut of ["rec2020", "p3", "srgb"]) {
        if (matchMedia(`(color-gamut: ${gamut})`).matches) {
          return gamut;
        }
      }
      return void 0;
    }
    function areColorsInverted() {
      if (doesMatch$5("inverted")) {
        return true;
      }
      if (doesMatch$5("none")) {
        return false;
      }
      return void 0;
    }
    function doesMatch$5(value) {
      return matchMedia(`(inverted-colors: ${value})`).matches;
    }
    function areColorsForced() {
      if (doesMatch$4("active")) {
        return true;
      }
      if (doesMatch$4("none")) {
        return false;
      }
      return void 0;
    }
    function doesMatch$4(value) {
      return matchMedia(`(forced-colors: ${value})`).matches;
    }
    var maxValueToCheck = 100;
    function getMonochromeDepth() {
      if (!matchMedia("(min-monochrome: 0)").matches) {
        return void 0;
      }
      for (let i = 0; i <= maxValueToCheck; ++i) {
        if (matchMedia(`(max-monochrome: ${i})`).matches) {
          return i;
        }
      }
      throw new Error("Too high value");
    }
    function getContrastPreference() {
      if (doesMatch$3("no-preference")) {
        return 0;
      }
      if (doesMatch$3("high") || doesMatch$3("more")) {
        return 1;
      }
      if (doesMatch$3("low") || doesMatch$3("less")) {
        return -1;
      }
      if (doesMatch$3("forced")) {
        return 10;
      }
      return void 0;
    }
    function doesMatch$3(value) {
      return matchMedia(`(prefers-contrast: ${value})`).matches;
    }
    function isMotionReduced() {
      if (doesMatch$2("reduce")) {
        return true;
      }
      if (doesMatch$2("no-preference")) {
        return false;
      }
      return void 0;
    }
    function doesMatch$2(value) {
      return matchMedia(`(prefers-reduced-motion: ${value})`).matches;
    }
    function isTransparencyReduced() {
      if (doesMatch$1("reduce")) {
        return true;
      }
      if (doesMatch$1("no-preference")) {
        return false;
      }
      return void 0;
    }
    function doesMatch$1(value) {
      return matchMedia(`(prefers-reduced-transparency: ${value})`).matches;
    }
    function isHDR() {
      if (doesMatch("high")) {
        return true;
      }
      if (doesMatch("standard")) {
        return false;
      }
      return void 0;
    }
    function doesMatch(value) {
      return matchMedia(`(dynamic-range: ${value})`).matches;
    }
    var M = Math;
    var fallbackFn = () => 0;
    function getMathFingerprint() {
      const acos = M.acos || fallbackFn;
      const acosh = M.acosh || fallbackFn;
      const asin = M.asin || fallbackFn;
      const asinh = M.asinh || fallbackFn;
      const atanh = M.atanh || fallbackFn;
      const atan = M.atan || fallbackFn;
      const sin = M.sin || fallbackFn;
      const sinh = M.sinh || fallbackFn;
      const cos = M.cos || fallbackFn;
      const cosh = M.cosh || fallbackFn;
      const tan = M.tan || fallbackFn;
      const tanh = M.tanh || fallbackFn;
      const exp = M.exp || fallbackFn;
      const expm1 = M.expm1 || fallbackFn;
      const log1p = M.log1p || fallbackFn;
      const powPI = (value) => M.pow(M.PI, value);
      const acoshPf = (value) => M.log(value + M.sqrt(value * value - 1));
      const asinhPf = (value) => M.log(value + M.sqrt(value * value + 1));
      const atanhPf = (value) => M.log((1 + value) / (1 - value)) / 2;
      const sinhPf = (value) => M.exp(value) - 1 / M.exp(value) / 2;
      const coshPf = (value) => (M.exp(value) + 1 / M.exp(value)) / 2;
      const expm1Pf = (value) => M.exp(value) - 1;
      const tanhPf = (value) => (M.exp(2 * value) - 1) / (M.exp(2 * value) + 1);
      const log1pPf = (value) => M.log(1 + value);
      return {
        acos: acos(0.12312423423423424),
        acosh: acosh(1e308),
        acoshPf: acoshPf(1e154),
        asin: asin(0.12312423423423424),
        asinh: asinh(1),
        asinhPf: asinhPf(1),
        atanh: atanh(0.5),
        atanhPf: atanhPf(0.5),
        atan: atan(0.5),
        sin: sin(-1e300),
        sinh: sinh(1),
        sinhPf: sinhPf(1),
        cos: cos(10.000000000123),
        cosh: cosh(1),
        coshPf: coshPf(1),
        tan: tan(-1e300),
        tanh: tanh(1),
        tanhPf: tanhPf(1),
        exp: exp(1),
        expm1: expm1(1),
        expm1Pf: expm1Pf(1),
        log1p: log1p(10),
        log1pPf: log1pPf(10),
        powPI: powPI(-100)
      };
    }
    var defaultText = "mmMwWLliI0fiflO&1";
    var presets = {
      /**
       * The default font. User can change it in desktop Chrome, desktop Firefox, IE 11,
       * Android Chrome (but only when the size is ≥ than the default) and Android Firefox.
       */
      default: [],
      /** OS font on macOS. User can change its size and weight. Applies after Safari restart. */
      apple: [{ font: "-apple-system-body" }],
      /** User can change it in desktop Chrome and desktop Firefox. */
      serif: [{ fontFamily: "serif" }],
      /** User can change it in desktop Chrome and desktop Firefox. */
      sans: [{ fontFamily: "sans-serif" }],
      /** User can change it in desktop Chrome and desktop Firefox. */
      mono: [{ fontFamily: "monospace" }],
      /**
       * Check the smallest allowed font size. User can change it in desktop Chrome, desktop Firefox and desktop Safari.
       * The height can be 0 in Chrome on a retina display.
       */
      min: [{ fontSize: "1px" }],
      /** Tells one OS from another in desktop Chrome. */
      system: [{ fontFamily: "system-ui" }]
    };
    function getFontPreferences() {
      return withNaturalFonts((document2, container) => {
        const elements = {};
        const sizes = {};
        for (const key of Object.keys(presets)) {
          const [style = {}, text = defaultText] = presets[key];
          const element = document2.createElement("span");
          element.textContent = text;
          element.style.whiteSpace = "nowrap";
          for (const name6 of Object.keys(style)) {
            const value = style[name6];
            if (value !== void 0) {
              element.style[name6] = value;
            }
          }
          elements[key] = element;
          container.append(document2.createElement("br"), element);
        }
        for (const key of Object.keys(presets)) {
          sizes[key] = elements[key].getBoundingClientRect().width;
        }
        return sizes;
      });
    }
    function withNaturalFonts(action, containerWidthPx = 4e3) {
      return withIframe((_, iframeWindow) => {
        const iframeDocument = iframeWindow.document;
        const iframeBody = iframeDocument.body;
        const bodyStyle = iframeBody.style;
        bodyStyle.width = `${containerWidthPx}px`;
        bodyStyle.webkitTextSizeAdjust = bodyStyle.textSizeAdjust = "none";
        if (isChromium()) {
          iframeBody.style.zoom = `${1 / iframeWindow.devicePixelRatio}`;
        } else if (isWebKit()) {
          iframeBody.style.zoom = "reset";
        }
        const linesOfText = iframeDocument.createElement("div");
        linesOfText.textContent = [...Array(containerWidthPx / 20 << 0)].map(() => "word").join(" ");
        iframeBody.appendChild(linesOfText);
        return action(iframeDocument, iframeBody);
      }, '<!doctype html><html><head><meta name="viewport" content="width=device-width, initial-scale=1">');
    }
    function isPdfViewerEnabled() {
      return navigator.pdfViewerEnabled;
    }
    function getArchitecture() {
      const f = new Float32Array(1);
      const u8 = new Uint8Array(f.buffer);
      f[0] = Infinity;
      f[0] = f[0] - f[0];
      return u8[3];
    }
    function getApplePayState() {
      const { ApplePaySession } = window;
      if (typeof (ApplePaySession === null || ApplePaySession === void 0 ? void 0 : ApplePaySession.canMakePayments) !== "function") {
        return -1;
      }
      if (willPrintConsoleError()) {
        return -3;
      }
      try {
        return ApplePaySession.canMakePayments() ? 1 : 0;
      } catch (error) {
        return getStateFromError(error);
      }
    }
    var willPrintConsoleError = isAnyParentCrossOrigin;
    function getStateFromError(error) {
      if (error instanceof Error && error.name === "InvalidAccessError" && /\bfrom\b.*\binsecure\b/i.test(error.message)) {
        return -2;
      }
      throw error;
    }
    function getPrivateClickMeasurement() {
      var _a;
      const link = document.createElement("a");
      const sourceId = (_a = link.attributionSourceId) !== null && _a !== void 0 ? _a : link.attributionsourceid;
      return sourceId === void 0 ? void 0 : String(sourceId);
    }
    var STATUS_NO_GL_CONTEXT = -1;
    var STATUS_GET_PARAMETER_NOT_A_FUNCTION = -2;
    var validContextParameters = /* @__PURE__ */ new Set([
      10752,
      2849,
      2884,
      2885,
      2886,
      2928,
      2929,
      2930,
      2931,
      2932,
      2960,
      2961,
      2962,
      2963,
      2964,
      2965,
      2966,
      2967,
      2968,
      2978,
      3024,
      3042,
      3088,
      3089,
      3106,
      3107,
      32773,
      32777,
      32777,
      32823,
      32824,
      32936,
      32937,
      32938,
      32939,
      32968,
      32969,
      32970,
      32971,
      3317,
      33170,
      3333,
      3379,
      3386,
      33901,
      33902,
      34016,
      34024,
      34076,
      3408,
      3410,
      3411,
      3412,
      3413,
      3414,
      3415,
      34467,
      34816,
      34817,
      34818,
      34819,
      34877,
      34921,
      34930,
      35660,
      35661,
      35724,
      35738,
      35739,
      36003,
      36004,
      36005,
      36347,
      36348,
      36349,
      37440,
      37441,
      37443,
      7936,
      7937,
      7938
      // SAMPLE_ALPHA_TO_COVERAGE (32926) and SAMPLE_COVERAGE (32928) are excluded because they trigger a console warning
      // in IE, Chrome ≤ 59 and Safari ≤ 13 and give no entropy.
    ]);
    var validExtensionParams = /* @__PURE__ */ new Set([
      34047,
      35723,
      36063,
      34852,
      34853,
      34854,
      34229,
      36392,
      36795,
      38449
      // MAX_VIEWS_OVR
    ]);
    var shaderTypes = ["FRAGMENT_SHADER", "VERTEX_SHADER"];
    var precisionTypes = ["LOW_FLOAT", "MEDIUM_FLOAT", "HIGH_FLOAT", "LOW_INT", "MEDIUM_INT", "HIGH_INT"];
    var rendererInfoExtensionName = "WEBGL_debug_renderer_info";
    var polygonModeExtensionName = "WEBGL_polygon_mode";
    function getWebGlBasics({ cache }) {
      var _a, _b, _c, _d, _e, _f;
      const gl = getWebGLContext(cache);
      if (!gl) {
        return STATUS_NO_GL_CONTEXT;
      }
      if (!isValidParameterGetter(gl)) {
        return STATUS_GET_PARAMETER_NOT_A_FUNCTION;
      }
      const debugExtension = shouldAvoidDebugRendererInfo() ? null : gl.getExtension(rendererInfoExtensionName);
      return {
        version: ((_a = gl.getParameter(gl.VERSION)) === null || _a === void 0 ? void 0 : _a.toString()) || "",
        vendor: ((_b = gl.getParameter(gl.VENDOR)) === null || _b === void 0 ? void 0 : _b.toString()) || "",
        vendorUnmasked: debugExtension ? (_c = gl.getParameter(debugExtension.UNMASKED_VENDOR_WEBGL)) === null || _c === void 0 ? void 0 : _c.toString() : "",
        renderer: ((_d = gl.getParameter(gl.RENDERER)) === null || _d === void 0 ? void 0 : _d.toString()) || "",
        rendererUnmasked: debugExtension ? (_e = gl.getParameter(debugExtension.UNMASKED_RENDERER_WEBGL)) === null || _e === void 0 ? void 0 : _e.toString() : "",
        shadingLanguageVersion: ((_f = gl.getParameter(gl.SHADING_LANGUAGE_VERSION)) === null || _f === void 0 ? void 0 : _f.toString()) || ""
      };
    }
    function getWebGlExtensions({ cache }) {
      const gl = getWebGLContext(cache);
      if (!gl) {
        return STATUS_NO_GL_CONTEXT;
      }
      if (!isValidParameterGetter(gl)) {
        return STATUS_GET_PARAMETER_NOT_A_FUNCTION;
      }
      const extensions = gl.getSupportedExtensions();
      const contextAttributes = gl.getContextAttributes();
      const unsupportedExtensions = [];
      const attributes = [];
      const parameters = [];
      const extensionParameters = [];
      const shaderPrecisions = [];
      if (contextAttributes) {
        for (const attributeName of Object.keys(contextAttributes)) {
          attributes.push(`${attributeName}=${contextAttributes[attributeName]}`);
        }
      }
      const constants = getConstantsFromPrototype(gl);
      for (const constant of constants) {
        const code = gl[constant];
        parameters.push(`${constant}=${code}${validContextParameters.has(code) ? `=${gl.getParameter(code)}` : ""}`);
      }
      if (extensions) {
        for (const name6 of extensions) {
          if (name6 === rendererInfoExtensionName && shouldAvoidDebugRendererInfo() || name6 === polygonModeExtensionName && shouldAvoidPolygonModeExtensions()) {
            continue;
          }
          const extension = gl.getExtension(name6);
          if (!extension) {
            unsupportedExtensions.push(name6);
            continue;
          }
          for (const constant of getConstantsFromPrototype(extension)) {
            const code = extension[constant];
            extensionParameters.push(`${constant}=${code}${validExtensionParams.has(code) ? `=${gl.getParameter(code)}` : ""}`);
          }
        }
      }
      for (const shaderType of shaderTypes) {
        for (const precisionType of precisionTypes) {
          const shaderPrecision = getShaderPrecision(gl, shaderType, precisionType);
          shaderPrecisions.push(`${shaderType}.${precisionType}=${shaderPrecision.join(",")}`);
        }
      }
      extensionParameters.sort();
      parameters.sort();
      return {
        contextAttributes: attributes,
        parameters,
        shaderPrecisions,
        extensions,
        extensionParameters,
        unsupportedExtensions
      };
    }
    function getWebGLContext(cache) {
      if (cache.webgl) {
        return cache.webgl.context;
      }
      const canvas = document.createElement("canvas");
      let context;
      canvas.addEventListener("webglCreateContextError", () => context = void 0);
      for (const type of ["webgl", "experimental-webgl"]) {
        try {
          context = canvas.getContext(type);
        } catch (_a) {
        }
        if (context) {
          break;
        }
      }
      cache.webgl = { context };
      return context;
    }
    function getShaderPrecision(gl, shaderType, precisionType) {
      const shaderPrecision = gl.getShaderPrecisionFormat(gl[shaderType], gl[precisionType]);
      return shaderPrecision ? [shaderPrecision.rangeMin, shaderPrecision.rangeMax, shaderPrecision.precision] : [];
    }
    function getConstantsFromPrototype(obj) {
      const keys = Object.keys(obj.__proto__);
      return keys.filter(isConstantLike);
    }
    function isConstantLike(key) {
      return typeof key === "string" && !key.match(/[^A-Z0-9_x]/);
    }
    function shouldAvoidDebugRendererInfo() {
      return isGecko();
    }
    function shouldAvoidPolygonModeExtensions() {
      return isChromium() || isWebKit();
    }
    function isValidParameterGetter(gl) {
      return typeof gl.getParameter === "function";
    }
    function getAudioContextBaseLatency() {
      const isAllowedPlatform = isAndroid() || isWebKit();
      if (!isAllowedPlatform) {
        return -2;
      }
      if (!window.AudioContext) {
        return -1;
      }
      const latency = new AudioContext().baseLatency;
      if (latency === null || latency === void 0) {
        return -1;
      }
      if (!isFinite(latency)) {
        return -3;
      }
      return latency;
    }
    function getDateTimeLocale() {
      if (!window.Intl) {
        return -1;
      }
      const DateTimeFormat = window.Intl.DateTimeFormat;
      if (!DateTimeFormat) {
        return -2;
      }
      const locale = DateTimeFormat().resolvedOptions().locale;
      if (!locale && locale !== "") {
        return -3;
      }
      return locale;
    }
    var sources = {
      // READ FIRST:
      // See https://github.com/fingerprintjs/fingerprintjs/blob/master/contributing.md#how-to-add-an-entropy-source
      // to learn how entropy source works and how to make your own.
      // The sources run in this exact order.
      // The asynchronous sources are at the start to run in parallel with other sources.
      fonts: getFonts,
      domBlockers: getDomBlockers,
      fontPreferences: getFontPreferences,
      audio: getAudioFingerprint,
      screenFrame: getScreenFrame,
      canvas: getCanvasFingerprint,
      osCpu: getOsCpu,
      languages: getLanguages,
      colorDepth: getColorDepth,
      deviceMemory: getDeviceMemory,
      screenResolution: getScreenResolution,
      hardwareConcurrency: getHardwareConcurrency,
      timezone: getTimezone,
      sessionStorage: getSessionStorage,
      localStorage: getLocalStorage,
      indexedDB: getIndexedDB,
      openDatabase: getOpenDatabase,
      cpuClass: getCpuClass,
      platform: getPlatform,
      plugins: getPlugins,
      touchSupport: getTouchSupport,
      vendor: getVendor,
      vendorFlavors: getVendorFlavors,
      cookiesEnabled: areCookiesEnabled,
      colorGamut: getColorGamut,
      invertedColors: areColorsInverted,
      forcedColors: areColorsForced,
      monochrome: getMonochromeDepth,
      contrast: getContrastPreference,
      reducedMotion: isMotionReduced,
      reducedTransparency: isTransparencyReduced,
      hdr: isHDR,
      math: getMathFingerprint,
      pdfViewerEnabled: isPdfViewerEnabled,
      architecture: getArchitecture,
      applePay: getApplePayState,
      privateClickMeasurement: getPrivateClickMeasurement,
      audioBaseLatency: getAudioContextBaseLatency,
      dateTimeLocale: getDateTimeLocale,
      // Some sources can affect other sources (e.g. WebGL can affect canvas), so it's important to run these sources
      // after other sources.
      webGlBasics: getWebGlBasics,
      webGlExtensions: getWebGlExtensions
    };
    function loadBuiltinSources(options) {
      return loadSources(sources, options, []);
    }
    var commentTemplate = "$ if upgrade to Pro: https://fpjs.dev/pro";
    function getConfidence(components) {
      const openConfidenceScore = getOpenConfidenceScore(components);
      const proConfidenceScore = deriveProConfidenceScore(openConfidenceScore);
      return { score: openConfidenceScore, comment: commentTemplate.replace(/\$/g, `${proConfidenceScore}`) };
    }
    function getOpenConfidenceScore(components) {
      if (isAndroid()) {
        return 0.4;
      }
      if (isWebKit()) {
        return isDesktopWebKit() && !(isWebKit616OrNewer() && isSafariWebKit()) ? 0.5 : 0.3;
      }
      const platform = "value" in components.platform ? components.platform.value : "";
      if (/^Win/.test(platform)) {
        return 0.6;
      }
      if (/^Mac/.test(platform)) {
        return 0.5;
      }
      return 0.7;
    }
    function deriveProConfidenceScore(openConfidenceScore) {
      return round(0.99 + 0.01 * openConfidenceScore, 1e-4);
    }
    function componentsToCanonicalString(components) {
      let result = "";
      for (const componentKey of Object.keys(components).sort()) {
        const component = components[componentKey];
        const value = "error" in component ? "error" : JSON.stringify(component.value);
        result += `${result ? "|" : ""}${componentKey.replace(/([:|\\])/g, "\\$1")}:${value}`;
      }
      return result;
    }
    function componentsToDebugString(components) {
      return JSON.stringify(components, (_key, value) => {
        if (value instanceof Error) {
          return errorToObject(value);
        }
        return value;
      }, 2);
    }
    function hashComponents(components) {
      return x64hash128(componentsToCanonicalString(components));
    }
    function makeLazyGetResult(components) {
      let visitorIdCache;
      const confidence = getConfidence(components);
      return {
        get visitorId() {
          if (visitorIdCache === void 0) {
            visitorIdCache = hashComponents(this.components);
          }
          return visitorIdCache;
        },
        set visitorId(visitorId) {
          visitorIdCache = visitorId;
        },
        confidence,
        components,
        version: version6
      };
    }
    function prepareForSources(delayFallback = 50) {
      return requestIdleCallbackIfAvailable(delayFallback, delayFallback * 2);
    }
    function makeAgent(getComponents, debug) {
      const creationTime = Date.now();
      return {
        async get(options) {
          const startTime = Date.now();
          const components = await getComponents();
          const result = makeLazyGetResult(components);
          if (debug || (options === null || options === void 0 ? void 0 : options.debug)) {
            console.log(`Copy the text below to get the debug data:

\`\`\`
version: ${result.version}
userAgent: ${navigator.userAgent}
timeBetweenLoadAndGet: ${startTime - creationTime}
visitorId: ${result.visitorId}
components: ${componentsToDebugString(components)}
\`\`\``);
          }
          return result;
        }
      };
    }
    function monitor() {
      if (window.__fpjs_d_m || Math.random() >= 1e-3) {
        return;
      }
      try {
        const request = new XMLHttpRequest();
        request.open("get", `https://m1.openfpcdn.io/fingerprintjs/v${version6}/npm-monitoring`, true);
        request.send();
      } catch (error) {
        console.error(error);
      }
    }
    async function load(options = {}) {
      var _a;
      if ((_a = options.monitoring) !== null && _a !== void 0 ? _a : true) {
        monitor();
      }
      const { delayFallback, debug } = options;
      await prepareForSources(delayFallback);
      const getComponents = loadBuiltinSources({ cache: {}, debug });
      return makeAgent(getComponents, debug);
    }
    var index = { load, hashComponents, componentsToDebugString };
    var murmurX64Hash128 = x64hash128;
    exports2.componentsToDebugString = componentsToDebugString;
    exports2.default = index;
    exports2.getFullscreenElement = getFullscreenElement;
    exports2.getUnstableAudioFingerprint = getUnstableAudioFingerprint;
    exports2.getUnstableCanvasFingerprint = getUnstableCanvasFingerprint;
    exports2.getUnstableScreenFrame = getUnstableScreenFrame;
    exports2.getUnstableScreenResolution = getUnstableScreenResolution;
    exports2.getWebGLContext = getWebGLContext;
    exports2.hashComponents = hashComponents;
    exports2.isAndroid = isAndroid;
    exports2.isChromium = isChromium;
    exports2.isDesktopWebKit = isDesktopWebKit;
    exports2.isEdgeHTML = isEdgeHTML;
    exports2.isGecko = isGecko;
    exports2.isSamsungInternet = isSamsungInternet;
    exports2.isTrident = isTrident;
    exports2.isWebKit = isWebKit;
    exports2.load = load;
    exports2.loadSources = loadSources;
    exports2.murmurX64Hash128 = murmurX64Hash128;
    exports2.prepareForSources = prepareForSources;
    exports2.sources = sources;
    exports2.transformSource = transformSource;
    exports2.withIframe = withIframe;
  }
});

// node_modules/@firebase/util/dist/postinstall.js
var require_postinstall = __commonJS({
  "node_modules/@firebase/util/dist/postinstall.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getDefaultsFromPostinstall = () => void 0;
  }
});

// node_modules/@firebase/util/dist/index.node.cjs.js
var require_index_node_cjs = __commonJS({
  "node_modules/@firebase/util/dist/index.node.cjs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var postinstall = require_postinstall();
    var CONSTANTS2 = {
      /**
       * @define {boolean} Whether this is the client Node.js SDK.
       */
      NODE_CLIENT: false,
      /**
       * @define {boolean} Whether this is the Admin Node.js SDK.
       */
      NODE_ADMIN: false,
      /**
       * Firebase SDK Version
       */
      SDK_VERSION: "${JSCORE_VERSION}"
    };
    var assert = function(assertion, message) {
      if (!assertion) {
        throw assertionError(message);
      }
    };
    var assertionError = function(message) {
      return new Error("Firebase Database (" + CONSTANTS2.SDK_VERSION + ") INTERNAL ASSERT FAILED: " + message);
    };
    var stringToByteArray$12 = function(str) {
      const out = [];
      let p = 0;
      for (let i = 0; i < str.length; i++) {
        let c = str.charCodeAt(i);
        if (c < 128) {
          out[p++] = c;
        } else if (c < 2048) {
          out[p++] = c >> 6 | 192;
          out[p++] = c & 63 | 128;
        } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
          c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
          out[p++] = c >> 18 | 240;
          out[p++] = c >> 12 & 63 | 128;
          out[p++] = c >> 6 & 63 | 128;
          out[p++] = c & 63 | 128;
        } else {
          out[p++] = c >> 12 | 224;
          out[p++] = c >> 6 & 63 | 128;
          out[p++] = c & 63 | 128;
        }
      }
      return out;
    };
    var byteArrayToString2 = function(bytes) {
      const out = [];
      let pos = 0, c = 0;
      while (pos < bytes.length) {
        const c1 = bytes[pos++];
        if (c1 < 128) {
          out[c++] = String.fromCharCode(c1);
        } else if (c1 > 191 && c1 < 224) {
          const c2 = bytes[pos++];
          out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
        } else if (c1 > 239 && c1 < 365) {
          const c2 = bytes[pos++];
          const c3 = bytes[pos++];
          const c4 = bytes[pos++];
          const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
          out[c++] = String.fromCharCode(55296 + (u >> 10));
          out[c++] = String.fromCharCode(56320 + (u & 1023));
        } else {
          const c2 = bytes[pos++];
          const c3 = bytes[pos++];
          out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
        }
      }
      return out.join("");
    };
    var base642 = {
      /**
       * Maps bytes to characters.
       */
      byteToCharMap_: null,
      /**
       * Maps characters to bytes.
       */
      charToByteMap_: null,
      /**
       * Maps bytes to websafe characters.
       * @private
       */
      byteToCharMapWebSafe_: null,
      /**
       * Maps websafe characters to bytes.
       * @private
       */
      charToByteMapWebSafe_: null,
      /**
       * Our default alphabet, shared between
       * ENCODED_VALS and ENCODED_VALS_WEBSAFE
       */
      ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
      /**
       * Our default alphabet. Value 64 (=) is special; it means "nothing."
       */
      get ENCODED_VALS() {
        return this.ENCODED_VALS_BASE + "+/=";
      },
      /**
       * Our websafe alphabet.
       */
      get ENCODED_VALS_WEBSAFE() {
        return this.ENCODED_VALS_BASE + "-_.";
      },
      /**
       * Whether this browser supports the atob and btoa functions. This extension
       * started at Mozilla but is now implemented by many browsers. We use the
       * ASSUME_* variables to avoid pulling in the full useragent detection library
       * but still allowing the standard per-browser compilations.
       *
       */
      HAS_NATIVE_SUPPORT: typeof atob === "function",
      /**
       * Base64-encode an array of bytes.
       *
       * @param input An array of bytes (numbers with
       *     value in [0, 255]) to encode.
       * @param webSafe Boolean indicating we should use the
       *     alternative alphabet.
       * @return The base64 encoded string.
       */
      encodeByteArray(input, webSafe) {
        if (!Array.isArray(input)) {
          throw Error("encodeByteArray takes an array as a parameter");
        }
        this.init_();
        const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
        const output = [];
        for (let i = 0; i < input.length; i += 3) {
          const byte1 = input[i];
          const haveByte2 = i + 1 < input.length;
          const byte2 = haveByte2 ? input[i + 1] : 0;
          const haveByte3 = i + 2 < input.length;
          const byte3 = haveByte3 ? input[i + 2] : 0;
          const outByte1 = byte1 >> 2;
          const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
          let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
          let outByte4 = byte3 & 63;
          if (!haveByte3) {
            outByte4 = 64;
            if (!haveByte2) {
              outByte3 = 64;
            }
          }
          output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
        }
        return output.join("");
      },
      /**
       * Base64-encode a string.
       *
       * @param input A string to encode.
       * @param webSafe If true, we should use the
       *     alternative alphabet.
       * @return The base64 encoded string.
       */
      encodeString(input, webSafe) {
        if (this.HAS_NATIVE_SUPPORT && !webSafe) {
          return btoa(input);
        }
        return this.encodeByteArray(stringToByteArray$12(input), webSafe);
      },
      /**
       * Base64-decode a string.
       *
       * @param input to decode.
       * @param webSafe True if we should use the
       *     alternative alphabet.
       * @return string representing the decoded value.
       */
      decodeString(input, webSafe) {
        if (this.HAS_NATIVE_SUPPORT && !webSafe) {
          return atob(input);
        }
        return byteArrayToString2(this.decodeStringToByteArray(input, webSafe));
      },
      /**
       * Base64-decode a string.
       *
       * In base-64 decoding, groups of four characters are converted into three
       * bytes.  If the encoder did not apply padding, the input length may not
       * be a multiple of 4.
       *
       * In this case, the last group will have fewer than 4 characters, and
       * padding will be inferred.  If the group has one or two characters, it decodes
       * to one byte.  If the group has three characters, it decodes to two bytes.
       *
       * @param input Input to decode.
       * @param webSafe True if we should use the web-safe alphabet.
       * @return bytes representing the decoded value.
       */
      decodeStringToByteArray(input, webSafe) {
        this.init_();
        const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
        const output = [];
        for (let i = 0; i < input.length; ) {
          const byte1 = charToByteMap[input.charAt(i++)];
          const haveByte2 = i < input.length;
          const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
          ++i;
          const haveByte3 = i < input.length;
          const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
          ++i;
          const haveByte4 = i < input.length;
          const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
          ++i;
          if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
            throw new DecodeBase64StringError2();
          }
          const outByte1 = byte1 << 2 | byte2 >> 4;
          output.push(outByte1);
          if (byte3 !== 64) {
            const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
            output.push(outByte2);
            if (byte4 !== 64) {
              const outByte3 = byte3 << 6 & 192 | byte4;
              output.push(outByte3);
            }
          }
        }
        return output;
      },
      /**
       * Lazy static initialization function. Called before
       * accessing any of the static map variables.
       * @private
       */
      init_() {
        if (!this.byteToCharMap_) {
          this.byteToCharMap_ = {};
          this.charToByteMap_ = {};
          this.byteToCharMapWebSafe_ = {};
          this.charToByteMapWebSafe_ = {};
          for (let i = 0; i < this.ENCODED_VALS.length; i++) {
            this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
            this.charToByteMap_[this.byteToCharMap_[i]] = i;
            this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
            this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
            if (i >= this.ENCODED_VALS_BASE.length) {
              this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
              this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
            }
          }
        }
      }
    };
    var DecodeBase64StringError2 = class extends Error {
      constructor() {
        super(...arguments);
        this.name = "DecodeBase64StringError";
      }
    };
    var base64Encode2 = function(str) {
      const utf8Bytes = stringToByteArray$12(str);
      return base642.encodeByteArray(utf8Bytes, true);
    };
    var base64urlEncodeWithoutPadding2 = function(str) {
      return base64Encode2(str).replace(/\./g, "");
    };
    var base64Decode2 = function(str) {
      try {
        return base642.decodeString(str, true);
      } catch (e) {
        console.error("base64Decode failed: ", e);
      }
      return null;
    };
    function deepCopy(value) {
      return deepExtend(void 0, value);
    }
    function deepExtend(target, source) {
      if (!(source instanceof Object)) {
        return source;
      }
      switch (source.constructor) {
        case Date:
          const dateValue = source;
          return new Date(dateValue.getTime());
        case Object:
          if (target === void 0) {
            target = {};
          }
          break;
        case Array:
          target = [];
          break;
        default:
          return source;
      }
      for (const prop in source) {
        if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {
          continue;
        }
        target[prop] = deepExtend(target[prop], source[prop]);
      }
      return target;
    }
    function isValidKey(key) {
      return key !== "__proto__";
    }
    function getGlobal2() {
      if (typeof self !== "undefined") {
        return self;
      }
      if (typeof window !== "undefined") {
        return window;
      }
      if (typeof global !== "undefined") {
        return global;
      }
      throw new Error("Unable to locate global object.");
    }
    var getDefaultsFromGlobal2 = () => getGlobal2().__FIREBASE_DEFAULTS__;
    var getDefaultsFromEnvVariable2 = () => {
      if (typeof process === "undefined" || typeof process.env === "undefined") {
        return;
      }
      const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;
      if (defaultsJsonString) {
        return JSON.parse(defaultsJsonString);
      }
    };
    var getDefaultsFromCookie2 = () => {
      if (typeof document === "undefined") {
        return;
      }
      let match;
      try {
        match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
      } catch (e) {
        return;
      }
      const decoded = match && base64Decode2(match[1]);
      return decoded && JSON.parse(decoded);
    };
    var getDefaults2 = () => {
      try {
        return postinstall.getDefaultsFromPostinstall() || getDefaultsFromGlobal2() || getDefaultsFromEnvVariable2() || getDefaultsFromCookie2();
      } catch (e) {
        console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);
        return;
      }
    };
    var getDefaultEmulatorHost2 = (productName) => getDefaults2()?.emulatorHosts?.[productName];
    var getDefaultEmulatorHostnameAndPort2 = (productName) => {
      const host = getDefaultEmulatorHost2(productName);
      if (!host) {
        return void 0;
      }
      const separatorIndex = host.lastIndexOf(":");
      if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {
        throw new Error(`Invalid host ${host} with no separate hostname and port!`);
      }
      const port = parseInt(host.substring(separatorIndex + 1), 10);
      if (host[0] === "[") {
        return [host.substring(1, separatorIndex - 1), port];
      } else {
        return [host.substring(0, separatorIndex), port];
      }
    };
    var getDefaultAppConfig2 = () => getDefaults2()?.config;
    var getExperimentalSetting = (name6) => getDefaults2()?.[`_${name6}`];
    var Deferred2 = class {
      constructor() {
        this.reject = () => {
        };
        this.resolve = () => {
        };
        this.promise = new Promise((resolve, reject) => {
          this.resolve = resolve;
          this.reject = reject;
        });
      }
      /**
       * Our API internals are not promisified and cannot because our callback APIs have subtle expectations around
       * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback
       * and returns a node-style callback which will resolve or reject the Deferred's promise.
       */
      wrapCallback(callback) {
        return (error, value) => {
          if (error) {
            this.reject(error);
          } else {
            this.resolve(value);
          }
          if (typeof callback === "function") {
            this.promise.catch(() => {
            });
            if (callback.length === 1) {
              callback(error);
            } else {
              callback(error, value);
            }
          }
        };
      }
    };
    function isCloudWorkstation2(url) {
      try {
        const host = url.startsWith("http://") || url.startsWith("https://") ? new URL(url).hostname : url;
        return host.endsWith(".cloudworkstations.dev");
      } catch {
        return false;
      }
    }
    async function pingServer2(endpoint) {
      const result = await fetch(endpoint, {
        credentials: "include"
      });
      return result.ok;
    }
    function createMockUserToken2(token, projectId) {
      if (token.uid) {
        throw new Error('The "uid" field is no longer supported by mockUserToken. Please use "sub" instead for Firebase Auth User ID.');
      }
      const header = {
        alg: "none",
        type: "JWT"
      };
      const project = projectId || "demo-project";
      const iat = token.iat || 0;
      const sub = token.sub || token.user_id;
      if (!sub) {
        throw new Error("mockUserToken must contain 'sub' or 'user_id' field!");
      }
      const payload = {
        // Set all required fields to decent defaults
        iss: `https://securetoken.google.com/${project}`,
        aud: project,
        iat,
        exp: iat + 3600,
        auth_time: iat,
        sub,
        user_id: sub,
        firebase: {
          sign_in_provider: "custom",
          identities: {}
        },
        // Override with user options
        ...token
      };
      const signature = "";
      return [
        base64urlEncodeWithoutPadding2(JSON.stringify(header)),
        base64urlEncodeWithoutPadding2(JSON.stringify(payload)),
        signature
      ].join(".");
    }
    var emulatorStatus2 = {};
    function getEmulatorSummary2() {
      const summary = {
        prod: [],
        emulator: []
      };
      for (const key of Object.keys(emulatorStatus2)) {
        if (emulatorStatus2[key]) {
          summary.emulator.push(key);
        } else {
          summary.prod.push(key);
        }
      }
      return summary;
    }
    function getOrCreateEl2(id) {
      let parentDiv = document.getElementById(id);
      let created = false;
      if (!parentDiv) {
        parentDiv = document.createElement("div");
        parentDiv.setAttribute("id", id);
        created = true;
      }
      return { created, element: parentDiv };
    }
    var previouslyDismissed2 = false;
    function updateEmulatorBanner2(name6, isRunningEmulator) {
      if (typeof window === "undefined" || typeof document === "undefined" || !isCloudWorkstation2(window.location.host) || emulatorStatus2[name6] === isRunningEmulator || emulatorStatus2[name6] || // If already set to use emulator, can't go back to prod.
      previouslyDismissed2) {
        return;
      }
      emulatorStatus2[name6] = isRunningEmulator;
      function prefixedId(id) {
        return `__firebase__banner__${id}`;
      }
      const bannerId = "__firebase__banner";
      const summary = getEmulatorSummary2();
      const showError = summary.prod.length > 0;
      function tearDown() {
        const element = document.getElementById(bannerId);
        if (element) {
          element.remove();
        }
      }
      function setupBannerStyles(bannerEl) {
        bannerEl.style.display = "flex";
        bannerEl.style.background = "#7faaf0";
        bannerEl.style.position = "fixed";
        bannerEl.style.bottom = "5px";
        bannerEl.style.left = "5px";
        bannerEl.style.padding = ".5em";
        bannerEl.style.borderRadius = "5px";
        bannerEl.style.alignItems = "center";
      }
      function setupIconStyles(prependIcon, iconId) {
        prependIcon.setAttribute("width", "24");
        prependIcon.setAttribute("id", iconId);
        prependIcon.setAttribute("height", "24");
        prependIcon.setAttribute("viewBox", "0 0 24 24");
        prependIcon.setAttribute("fill", "none");
        prependIcon.style.marginLeft = "-6px";
      }
      function setupCloseBtn() {
        const closeBtn = document.createElement("span");
        closeBtn.style.cursor = "pointer";
        closeBtn.style.marginLeft = "16px";
        closeBtn.style.fontSize = "24px";
        closeBtn.innerHTML = " &times;";
        closeBtn.onclick = () => {
          previouslyDismissed2 = true;
          tearDown();
        };
        return closeBtn;
      }
      function setupLinkStyles(learnMoreLink, learnMoreId) {
        learnMoreLink.setAttribute("id", learnMoreId);
        learnMoreLink.innerText = "Learn more";
        learnMoreLink.href = "https://firebase.google.com/docs/studio/preview-apps#preview-backend";
        learnMoreLink.setAttribute("target", "__blank");
        learnMoreLink.style.paddingLeft = "5px";
        learnMoreLink.style.textDecoration = "underline";
      }
      function setupDom() {
        const banner = getOrCreateEl2(bannerId);
        const firebaseTextId = prefixedId("text");
        const firebaseText = document.getElementById(firebaseTextId) || document.createElement("span");
        const learnMoreId = prefixedId("learnmore");
        const learnMoreLink = document.getElementById(learnMoreId) || document.createElement("a");
        const prependIconId = prefixedId("preprendIcon");
        const prependIcon = document.getElementById(prependIconId) || document.createElementNS("http://www.w3.org/2000/svg", "svg");
        if (banner.created) {
          const bannerEl = banner.element;
          setupBannerStyles(bannerEl);
          setupLinkStyles(learnMoreLink, learnMoreId);
          const closeBtn = setupCloseBtn();
          setupIconStyles(prependIcon, prependIconId);
          bannerEl.append(prependIcon, firebaseText, learnMoreLink, closeBtn);
          document.body.appendChild(bannerEl);
        }
        if (showError) {
          firebaseText.innerText = `Preview backend disconnected.`;
          prependIcon.innerHTML = `<g clip-path="url(#clip0_6013_33858)">
<path d="M4.8 17.6L12 5.6L19.2 17.6H4.8ZM6.91667 16.4H17.0833L12 7.93333L6.91667 16.4ZM12 15.6C12.1667 15.6 12.3056 15.5444 12.4167 15.4333C12.5389 15.3111 12.6 15.1667 12.6 15C12.6 14.8333 12.5389 14.6944 12.4167 14.5833C12.3056 14.4611 12.1667 14.4 12 14.4C11.8333 14.4 11.6889 14.4611 11.5667 14.5833C11.4556 14.6944 11.4 14.8333 11.4 15C11.4 15.1667 11.4556 15.3111 11.5667 15.4333C11.6889 15.5444 11.8333 15.6 12 15.6ZM11.4 13.6H12.6V10.4H11.4V13.6Z" fill="#212121"/>
</g>
<defs>
<clipPath id="clip0_6013_33858">
<rect width="24" height="24" fill="white"/>
</clipPath>
</defs>`;
        } else {
          prependIcon.innerHTML = `<g clip-path="url(#clip0_6083_34804)">
<path d="M11.4 15.2H12.6V11.2H11.4V15.2ZM12 10C12.1667 10 12.3056 9.94444 12.4167 9.83333C12.5389 9.71111 12.6 9.56667 12.6 9.4C12.6 9.23333 12.5389 9.09444 12.4167 8.98333C12.3056 8.86111 12.1667 8.8 12 8.8C11.8333 8.8 11.6889 8.86111 11.5667 8.98333C11.4556 9.09444 11.4 9.23333 11.4 9.4C11.4 9.56667 11.4556 9.71111 11.5667 9.83333C11.6889 9.94444 11.8333 10 12 10ZM12 18.4C11.1222 18.4 10.2944 18.2333 9.51667 17.9C8.73889 17.5667 8.05556 17.1111 7.46667 16.5333C6.88889 15.9444 6.43333 15.2611 6.1 14.4833C5.76667 13.7056 5.6 12.8778 5.6 12C5.6 11.1111 5.76667 10.2833 6.1 9.51667C6.43333 8.73889 6.88889 8.06111 7.46667 7.48333C8.05556 6.89444 8.73889 6.43333 9.51667 6.1C10.2944 5.76667 11.1222 5.6 12 5.6C12.8889 5.6 13.7167 5.76667 14.4833 6.1C15.2611 6.43333 15.9389 6.89444 16.5167 7.48333C17.1056 8.06111 17.5667 8.73889 17.9 9.51667C18.2333 10.2833 18.4 11.1111 18.4 12C18.4 12.8778 18.2333 13.7056 17.9 14.4833C17.5667 15.2611 17.1056 15.9444 16.5167 16.5333C15.9389 17.1111 15.2611 17.5667 14.4833 17.9C13.7167 18.2333 12.8889 18.4 12 18.4ZM12 17.2C13.4444 17.2 14.6722 16.6944 15.6833 15.6833C16.6944 14.6722 17.2 13.4444 17.2 12C17.2 10.5556 16.6944 9.32778 15.6833 8.31667C14.6722 7.30555 13.4444 6.8 12 6.8C10.5556 6.8 9.32778 7.30555 8.31667 8.31667C7.30556 9.32778 6.8 10.5556 6.8 12C6.8 13.4444 7.30556 14.6722 8.31667 15.6833C9.32778 16.6944 10.5556 17.2 12 17.2Z" fill="#212121"/>
</g>
<defs>
<clipPath id="clip0_6083_34804">
<rect width="24" height="24" fill="white"/>
</clipPath>
</defs>`;
          firebaseText.innerText = "Preview backend running in this workspace.";
        }
        firebaseText.setAttribute("id", firebaseTextId);
      }
      if (document.readyState === "loading") {
        window.addEventListener("DOMContentLoaded", setupDom);
      } else {
        setupDom();
      }
    }
    function getUA2() {
      if (typeof navigator !== "undefined" && typeof navigator["userAgent"] === "string") {
        return navigator["userAgent"];
      } else {
        return "";
      }
    }
    function isMobileCordova2() {
      return typeof window !== "undefined" && // @ts-ignore Setting up an broadly applicable index signature for Window
      // just to deal with this case would probably be a bad idea.
      !!(window["cordova"] || window["phonegap"] || window["PhoneGap"]) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA2());
    }
    function isNode() {
      const forceEnvironment = getDefaults2()?.forceEnvironment;
      if (forceEnvironment === "node") {
        return true;
      } else if (forceEnvironment === "browser") {
        return false;
      }
      try {
        return Object.prototype.toString.call(global.process) === "[object process]";
      } catch (e) {
        return false;
      }
    }
    function isBrowser2() {
      return typeof window !== "undefined" || isWebWorker2();
    }
    function isWebWorker2() {
      return typeof WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof WorkerGlobalScope;
    }
    function isCloudflareWorker2() {
      return typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers";
    }
    function isBrowserExtension2() {
      const runtime = typeof chrome === "object" ? chrome.runtime : typeof browser === "object" ? browser.runtime : void 0;
      return typeof runtime === "object" && runtime.id !== void 0;
    }
    function isReactNative2() {
      return typeof navigator === "object" && navigator["product"] === "ReactNative";
    }
    function isElectron() {
      return getUA2().indexOf("Electron/") >= 0;
    }
    function isIE2() {
      const ua = getUA2();
      return ua.indexOf("MSIE ") >= 0 || ua.indexOf("Trident/") >= 0;
    }
    function isUWP() {
      return getUA2().indexOf("MSAppHost/") >= 0;
    }
    function isNodeSdk() {
      return CONSTANTS2.NODE_CLIENT === true || CONSTANTS2.NODE_ADMIN === true;
    }
    function isSafari() {
      return !isNode() && !!navigator.userAgent && navigator.userAgent.includes("Safari") && !navigator.userAgent.includes("Chrome");
    }
    function isSafariOrWebkit() {
      return !isNode() && !!navigator.userAgent && (navigator.userAgent.includes("Safari") || navigator.userAgent.includes("WebKit")) && !navigator.userAgent.includes("Chrome");
    }
    function isIndexedDBAvailable2() {
      try {
        return typeof indexedDB === "object";
      } catch (e) {
        return false;
      }
    }
    function validateIndexedDBOpenable2() {
      return new Promise((resolve, reject) => {
        try {
          let preExist = true;
          const DB_CHECK_NAME = "validate-browser-context-for-indexeddb-analytics-module";
          const request = self.indexedDB.open(DB_CHECK_NAME);
          request.onsuccess = () => {
            request.result.close();
            if (!preExist) {
              self.indexedDB.deleteDatabase(DB_CHECK_NAME);
            }
            resolve(true);
          };
          request.onupgradeneeded = () => {
            preExist = false;
          };
          request.onerror = () => {
            reject(request.error?.message || "");
          };
        } catch (error) {
          reject(error);
        }
      });
    }
    function areCookiesEnabled() {
      if (typeof navigator === "undefined" || !navigator.cookieEnabled) {
        return false;
      }
      return true;
    }
    var ERROR_NAME2 = "FirebaseError";
    var FirebaseError2 = class _FirebaseError extends Error {
      constructor(code, message, customData) {
        super(message);
        this.code = code;
        this.customData = customData;
        this.name = ERROR_NAME2;
        Object.setPrototypeOf(this, _FirebaseError.prototype);
        if (Error.captureStackTrace) {
          Error.captureStackTrace(this, ErrorFactory2.prototype.create);
        }
      }
    };
    var ErrorFactory2 = class {
      constructor(service, serviceName, errors) {
        this.service = service;
        this.serviceName = serviceName;
        this.errors = errors;
      }
      create(code, ...data) {
        const customData = data[0] || {};
        const fullCode = `${this.service}/${code}`;
        const template = this.errors[code];
        const message = template ? replaceTemplate2(template, customData) : "Error";
        const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;
        const error = new FirebaseError2(fullCode, fullMessage, customData);
        return error;
      }
    };
    function replaceTemplate2(template, data) {
      return template.replace(PATTERN2, (_, key) => {
        const value = data[key];
        return value != null ? String(value) : `<${key}?>`;
      });
    }
    var PATTERN2 = /\{\$([^}]+)}/g;
    function jsonEval(str) {
      return JSON.parse(str);
    }
    function stringify(data) {
      return JSON.stringify(data);
    }
    var decode2 = function(token) {
      let header = {}, claims = {}, data = {}, signature = "";
      try {
        const parts = token.split(".");
        header = jsonEval(base64Decode2(parts[0]) || "");
        claims = jsonEval(base64Decode2(parts[1]) || "");
        signature = parts[2];
        data = claims["d"] || {};
        delete claims["d"];
      } catch (e) {
      }
      return {
        header,
        claims,
        data,
        signature
      };
    };
    var isValidTimestamp = function(token) {
      const claims = decode2(token).claims;
      const now = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
      let validSince = 0, validUntil = 0;
      if (typeof claims === "object") {
        if (claims.hasOwnProperty("nbf")) {
          validSince = claims["nbf"];
        } else if (claims.hasOwnProperty("iat")) {
          validSince = claims["iat"];
        }
        if (claims.hasOwnProperty("exp")) {
          validUntil = claims["exp"];
        } else {
          validUntil = validSince + 86400;
        }
      }
      return !!now && !!validSince && !!validUntil && now >= validSince && now <= validUntil;
    };
    var issuedAtTime = function(token) {
      const claims = decode2(token).claims;
      if (typeof claims === "object" && claims.hasOwnProperty("iat")) {
        return claims["iat"];
      }
      return null;
    };
    var isValidFormat = function(token) {
      const decoded = decode2(token), claims = decoded.claims;
      return !!claims && typeof claims === "object" && claims.hasOwnProperty("iat");
    };
    var isAdmin = function(token) {
      const claims = decode2(token).claims;
      return typeof claims === "object" && claims["admin"] === true;
    };
    function contains(obj, key) {
      return Object.prototype.hasOwnProperty.call(obj, key);
    }
    function safeGet(obj, key) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        return obj[key];
      } else {
        return void 0;
      }
    }
    function isEmpty(obj) {
      for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          return false;
        }
      }
      return true;
    }
    function map(obj, fn, contextObj) {
      const res = {};
      for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          res[key] = fn.call(contextObj, obj[key], key, obj);
        }
      }
      return res;
    }
    function deepEqual2(a, b) {
      if (a === b) {
        return true;
      }
      const aKeys = Object.keys(a);
      const bKeys = Object.keys(b);
      for (const k of aKeys) {
        if (!bKeys.includes(k)) {
          return false;
        }
        const aProp = a[k];
        const bProp = b[k];
        if (isObject2(aProp) && isObject2(bProp)) {
          if (!deepEqual2(aProp, bProp)) {
            return false;
          }
        } else if (aProp !== bProp) {
          return false;
        }
      }
      for (const k of bKeys) {
        if (!aKeys.includes(k)) {
          return false;
        }
      }
      return true;
    }
    function isObject2(thing) {
      return thing !== null && typeof thing === "object";
    }
    function promiseWithTimeout(promise, timeInMS = 2e3) {
      const deferredPromise = new Deferred2();
      setTimeout(() => deferredPromise.reject("timeout!"), timeInMS);
      promise.then(deferredPromise.resolve, deferredPromise.reject);
      return deferredPromise.promise;
    }
    function querystring2(querystringParams) {
      const params = [];
      for (const [key, value] of Object.entries(querystringParams)) {
        if (Array.isArray(value)) {
          value.forEach((arrayVal) => {
            params.push(encodeURIComponent(key) + "=" + encodeURIComponent(arrayVal));
          });
        } else {
          params.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
        }
      }
      return params.length ? "&" + params.join("&") : "";
    }
    function querystringDecode2(querystring3) {
      const obj = {};
      const tokens = querystring3.replace(/^\?/, "").split("&");
      tokens.forEach((token) => {
        if (token) {
          const [key, value] = token.split("=");
          obj[decodeURIComponent(key)] = decodeURIComponent(value);
        }
      });
      return obj;
    }
    function extractQuerystring2(url) {
      const queryStart = url.indexOf("?");
      if (!queryStart) {
        return "";
      }
      const fragmentStart = url.indexOf("#", queryStart);
      return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : void 0);
    }
    var Sha1 = class {
      constructor() {
        this.chain_ = [];
        this.buf_ = [];
        this.W_ = [];
        this.pad_ = [];
        this.inbuf_ = 0;
        this.total_ = 0;
        this.blockSize = 512 / 8;
        this.pad_[0] = 128;
        for (let i = 1; i < this.blockSize; ++i) {
          this.pad_[i] = 0;
        }
        this.reset();
      }
      reset() {
        this.chain_[0] = 1732584193;
        this.chain_[1] = 4023233417;
        this.chain_[2] = 2562383102;
        this.chain_[3] = 271733878;
        this.chain_[4] = 3285377520;
        this.inbuf_ = 0;
        this.total_ = 0;
      }
      /**
       * Internal compress helper function.
       * @param buf Block to compress.
       * @param offset Offset of the block in the buffer.
       * @private
       */
      compress_(buf, offset) {
        if (!offset) {
          offset = 0;
        }
        const W = this.W_;
        if (typeof buf === "string") {
          for (let i = 0; i < 16; i++) {
            W[i] = buf.charCodeAt(offset) << 24 | buf.charCodeAt(offset + 1) << 16 | buf.charCodeAt(offset + 2) << 8 | buf.charCodeAt(offset + 3);
            offset += 4;
          }
        } else {
          for (let i = 0; i < 16; i++) {
            W[i] = buf[offset] << 24 | buf[offset + 1] << 16 | buf[offset + 2] << 8 | buf[offset + 3];
            offset += 4;
          }
        }
        for (let i = 16; i < 80; i++) {
          const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
          W[i] = (t << 1 | t >>> 31) & 4294967295;
        }
        let a = this.chain_[0];
        let b = this.chain_[1];
        let c = this.chain_[2];
        let d = this.chain_[3];
        let e = this.chain_[4];
        let f, k;
        for (let i = 0; i < 80; i++) {
          if (i < 40) {
            if (i < 20) {
              f = d ^ b & (c ^ d);
              k = 1518500249;
            } else {
              f = b ^ c ^ d;
              k = 1859775393;
            }
          } else {
            if (i < 60) {
              f = b & c | d & (b | c);
              k = 2400959708;
            } else {
              f = b ^ c ^ d;
              k = 3395469782;
            }
          }
          const t = (a << 5 | a >>> 27) + f + e + k + W[i] & 4294967295;
          e = d;
          d = c;
          c = (b << 30 | b >>> 2) & 4294967295;
          b = a;
          a = t;
        }
        this.chain_[0] = this.chain_[0] + a & 4294967295;
        this.chain_[1] = this.chain_[1] + b & 4294967295;
        this.chain_[2] = this.chain_[2] + c & 4294967295;
        this.chain_[3] = this.chain_[3] + d & 4294967295;
        this.chain_[4] = this.chain_[4] + e & 4294967295;
      }
      update(bytes, length) {
        if (bytes == null) {
          return;
        }
        if (length === void 0) {
          length = bytes.length;
        }
        const lengthMinusBlock = length - this.blockSize;
        let n = 0;
        const buf = this.buf_;
        let inbuf = this.inbuf_;
        while (n < length) {
          if (inbuf === 0) {
            while (n <= lengthMinusBlock) {
              this.compress_(bytes, n);
              n += this.blockSize;
            }
          }
          if (typeof bytes === "string") {
            while (n < length) {
              buf[inbuf] = bytes.charCodeAt(n);
              ++inbuf;
              ++n;
              if (inbuf === this.blockSize) {
                this.compress_(buf);
                inbuf = 0;
                break;
              }
            }
          } else {
            while (n < length) {
              buf[inbuf] = bytes[n];
              ++inbuf;
              ++n;
              if (inbuf === this.blockSize) {
                this.compress_(buf);
                inbuf = 0;
                break;
              }
            }
          }
        }
        this.inbuf_ = inbuf;
        this.total_ += length;
      }
      /** @override */
      digest() {
        const digest = [];
        let totalBits = this.total_ * 8;
        if (this.inbuf_ < 56) {
          this.update(this.pad_, 56 - this.inbuf_);
        } else {
          this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));
        }
        for (let i = this.blockSize - 1; i >= 56; i--) {
          this.buf_[i] = totalBits & 255;
          totalBits /= 256;
        }
        this.compress_(this.buf_);
        let n = 0;
        for (let i = 0; i < 5; i++) {
          for (let j = 24; j >= 0; j -= 8) {
            digest[n] = this.chain_[i] >> j & 255;
            ++n;
          }
        }
        return digest;
      }
    };
    function createSubscribe2(executor, onNoObservers) {
      const proxy = new ObserverProxy2(executor, onNoObservers);
      return proxy.subscribe.bind(proxy);
    }
    var ObserverProxy2 = class {
      /**
       * @param executor Function which can make calls to a single Observer
       *     as a proxy.
       * @param onNoObservers Callback when count of Observers goes to zero.
       */
      constructor(executor, onNoObservers) {
        this.observers = [];
        this.unsubscribes = [];
        this.observerCount = 0;
        this.task = Promise.resolve();
        this.finalized = false;
        this.onNoObservers = onNoObservers;
        this.task.then(() => {
          executor(this);
        }).catch((e) => {
          this.error(e);
        });
      }
      next(value) {
        this.forEachObserver((observer) => {
          observer.next(value);
        });
      }
      error(error) {
        this.forEachObserver((observer) => {
          observer.error(error);
        });
        this.close(error);
      }
      complete() {
        this.forEachObserver((observer) => {
          observer.complete();
        });
        this.close();
      }
      /**
       * Subscribe function that can be used to add an Observer to the fan-out list.
       *
       * - We require that no event is sent to a subscriber synchronously to their
       *   call to subscribe().
       */
      subscribe(nextOrObserver, error, complete) {
        let observer;
        if (nextOrObserver === void 0 && error === void 0 && complete === void 0) {
          throw new Error("Missing Observer.");
        }
        if (implementsAnyMethods2(nextOrObserver, [
          "next",
          "error",
          "complete"
        ])) {
          observer = nextOrObserver;
        } else {
          observer = {
            next: nextOrObserver,
            error,
            complete
          };
        }
        if (observer.next === void 0) {
          observer.next = noop2;
        }
        if (observer.error === void 0) {
          observer.error = noop2;
        }
        if (observer.complete === void 0) {
          observer.complete = noop2;
        }
        const unsub = this.unsubscribeOne.bind(this, this.observers.length);
        if (this.finalized) {
          this.task.then(() => {
            try {
              if (this.finalError) {
                observer.error(this.finalError);
              } else {
                observer.complete();
              }
            } catch (e) {
            }
            return;
          });
        }
        this.observers.push(observer);
        return unsub;
      }
      // Unsubscribe is synchronous - we guarantee that no events are sent to
      // any unsubscribed Observer.
      unsubscribeOne(i) {
        if (this.observers === void 0 || this.observers[i] === void 0) {
          return;
        }
        delete this.observers[i];
        this.observerCount -= 1;
        if (this.observerCount === 0 && this.onNoObservers !== void 0) {
          this.onNoObservers(this);
        }
      }
      forEachObserver(fn) {
        if (this.finalized) {
          return;
        }
        for (let i = 0; i < this.observers.length; i++) {
          this.sendOne(i, fn);
        }
      }
      // Call the Observer via one of it's callback function. We are careful to
      // confirm that the observe has not been unsubscribed since this asynchronous
      // function had been queued.
      sendOne(i, fn) {
        this.task.then(() => {
          if (this.observers !== void 0 && this.observers[i] !== void 0) {
            try {
              fn(this.observers[i]);
            } catch (e) {
              if (typeof console !== "undefined" && console.error) {
                console.error(e);
              }
            }
          }
        });
      }
      close(err) {
        if (this.finalized) {
          return;
        }
        this.finalized = true;
        if (err !== void 0) {
          this.finalError = err;
        }
        this.task.then(() => {
          this.observers = void 0;
          this.onNoObservers = void 0;
        });
      }
    };
    function async(fn, onError) {
      return (...args) => {
        Promise.resolve(true).then(() => {
          fn(...args);
        }).catch((error) => {
          if (onError) {
            onError(error);
          }
        });
      };
    }
    function implementsAnyMethods2(obj, methods) {
      if (typeof obj !== "object" || obj === null) {
        return false;
      }
      for (const method of methods) {
        if (method in obj && typeof obj[method] === "function") {
          return true;
        }
      }
      return false;
    }
    function noop2() {
    }
    var validateArgCount = function(fnName, minCount, maxCount, argCount) {
      let argError;
      if (argCount < minCount) {
        argError = "at least " + minCount;
      } else if (argCount > maxCount) {
        argError = maxCount === 0 ? "none" : "no more than " + maxCount;
      }
      if (argError) {
        const error = fnName + " failed: Was called with " + argCount + (argCount === 1 ? " argument." : " arguments.") + " Expects " + argError + ".";
        throw new Error(error);
      }
    };
    function errorPrefix(fnName, argName) {
      return `${fnName} failed: ${argName} argument `;
    }
    function validateNamespace(fnName, namespace, optional) {
      if (optional && !namespace) {
        return;
      }
      if (typeof namespace !== "string") {
        throw new Error(errorPrefix(fnName, "namespace") + "must be a valid firebase namespace.");
      }
    }
    function validateCallback(fnName, argumentName, callback, optional) {
      if (optional && !callback) {
        return;
      }
      if (typeof callback !== "function") {
        throw new Error(errorPrefix(fnName, argumentName) + "must be a valid function.");
      }
    }
    function validateContextObject(fnName, argumentName, context, optional) {
      if (optional && !context) {
        return;
      }
      if (typeof context !== "object" || context === null) {
        throw new Error(errorPrefix(fnName, argumentName) + "must be a valid context object.");
      }
    }
    var stringToByteArray = function(str) {
      const out = [];
      let p = 0;
      for (let i = 0; i < str.length; i++) {
        let c = str.charCodeAt(i);
        if (c >= 55296 && c <= 56319) {
          const high = c - 55296;
          i++;
          assert(i < str.length, "Surrogate pair missing trail surrogate.");
          const low = str.charCodeAt(i) - 56320;
          c = 65536 + (high << 10) + low;
        }
        if (c < 128) {
          out[p++] = c;
        } else if (c < 2048) {
          out[p++] = c >> 6 | 192;
          out[p++] = c & 63 | 128;
        } else if (c < 65536) {
          out[p++] = c >> 12 | 224;
          out[p++] = c >> 6 & 63 | 128;
          out[p++] = c & 63 | 128;
        } else {
          out[p++] = c >> 18 | 240;
          out[p++] = c >> 12 & 63 | 128;
          out[p++] = c >> 6 & 63 | 128;
          out[p++] = c & 63 | 128;
        }
      }
      return out;
    };
    var stringLength = function(str) {
      let p = 0;
      for (let i = 0; i < str.length; i++) {
        const c = str.charCodeAt(i);
        if (c < 128) {
          p++;
        } else if (c < 2048) {
          p += 2;
        } else if (c >= 55296 && c <= 56319) {
          p += 4;
          i++;
        } else {
          p += 3;
        }
      }
      return p;
    };
    var DEFAULT_INTERVAL_MILLIS = 1e3;
    var DEFAULT_BACKOFF_FACTOR = 2;
    var MAX_VALUE_MILLIS2 = 4 * 60 * 60 * 1e3;
    var RANDOM_FACTOR = 0.5;
    function calculateBackoffMillis(backoffCount, intervalMillis = DEFAULT_INTERVAL_MILLIS, backoffFactor = DEFAULT_BACKOFF_FACTOR) {
      const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);
      const randomWait = Math.round(
        // A fraction of the backoff value to add/subtract.
        // Deviation: changes multiplication order to improve readability.
        RANDOM_FACTOR * currBaseValue * // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines
        // if we add or subtract.
        (Math.random() - 0.5) * 2
      );
      return Math.min(MAX_VALUE_MILLIS2, currBaseValue + randomWait);
    }
    function ordinal(i) {
      if (!Number.isFinite(i)) {
        return `${i}`;
      }
      return i + indicator(i);
    }
    function indicator(i) {
      i = Math.abs(i);
      const cent = i % 100;
      if (cent >= 10 && cent <= 20) {
        return "th";
      }
      const dec = i % 10;
      if (dec === 1) {
        return "st";
      }
      if (dec === 2) {
        return "nd";
      }
      if (dec === 3) {
        return "rd";
      }
      return "th";
    }
    function getModularInstance2(service) {
      if (service && service._delegate) {
        return service._delegate;
      } else {
        return service;
      }
    }
    CONSTANTS2.NODE_CLIENT = true;
    exports2.CONSTANTS = CONSTANTS2;
    exports2.DecodeBase64StringError = DecodeBase64StringError2;
    exports2.Deferred = Deferred2;
    exports2.ErrorFactory = ErrorFactory2;
    exports2.FirebaseError = FirebaseError2;
    exports2.MAX_VALUE_MILLIS = MAX_VALUE_MILLIS2;
    exports2.RANDOM_FACTOR = RANDOM_FACTOR;
    exports2.Sha1 = Sha1;
    exports2.areCookiesEnabled = areCookiesEnabled;
    exports2.assert = assert;
    exports2.assertionError = assertionError;
    exports2.async = async;
    exports2.base64 = base642;
    exports2.base64Decode = base64Decode2;
    exports2.base64Encode = base64Encode2;
    exports2.base64urlEncodeWithoutPadding = base64urlEncodeWithoutPadding2;
    exports2.calculateBackoffMillis = calculateBackoffMillis;
    exports2.contains = contains;
    exports2.createMockUserToken = createMockUserToken2;
    exports2.createSubscribe = createSubscribe2;
    exports2.decode = decode2;
    exports2.deepCopy = deepCopy;
    exports2.deepEqual = deepEqual2;
    exports2.deepExtend = deepExtend;
    exports2.errorPrefix = errorPrefix;
    exports2.extractQuerystring = extractQuerystring2;
    exports2.getDefaultAppConfig = getDefaultAppConfig2;
    exports2.getDefaultEmulatorHost = getDefaultEmulatorHost2;
    exports2.getDefaultEmulatorHostnameAndPort = getDefaultEmulatorHostnameAndPort2;
    exports2.getDefaults = getDefaults2;
    exports2.getExperimentalSetting = getExperimentalSetting;
    exports2.getGlobal = getGlobal2;
    exports2.getModularInstance = getModularInstance2;
    exports2.getUA = getUA2;
    exports2.isAdmin = isAdmin;
    exports2.isBrowser = isBrowser2;
    exports2.isBrowserExtension = isBrowserExtension2;
    exports2.isCloudWorkstation = isCloudWorkstation2;
    exports2.isCloudflareWorker = isCloudflareWorker2;
    exports2.isElectron = isElectron;
    exports2.isEmpty = isEmpty;
    exports2.isIE = isIE2;
    exports2.isIndexedDBAvailable = isIndexedDBAvailable2;
    exports2.isMobileCordova = isMobileCordova2;
    exports2.isNode = isNode;
    exports2.isNodeSdk = isNodeSdk;
    exports2.isReactNative = isReactNative2;
    exports2.isSafari = isSafari;
    exports2.isSafariOrWebkit = isSafariOrWebkit;
    exports2.isUWP = isUWP;
    exports2.isValidFormat = isValidFormat;
    exports2.isValidTimestamp = isValidTimestamp;
    exports2.isWebWorker = isWebWorker2;
    exports2.issuedAtTime = issuedAtTime;
    exports2.jsonEval = jsonEval;
    exports2.map = map;
    exports2.ordinal = ordinal;
    exports2.pingServer = pingServer2;
    exports2.promiseWithTimeout = promiseWithTimeout;
    exports2.querystring = querystring2;
    exports2.querystringDecode = querystringDecode2;
    exports2.safeGet = safeGet;
    exports2.stringLength = stringLength;
    exports2.stringToByteArray = stringToByteArray;
    exports2.stringify = stringify;
    exports2.updateEmulatorBanner = updateEmulatorBanner2;
    exports2.validateArgCount = validateArgCount;
    exports2.validateCallback = validateCallback;
    exports2.validateContextObject = validateContextObject;
    exports2.validateIndexedDBOpenable = validateIndexedDBOpenable2;
    exports2.validateNamespace = validateNamespace;
  }
});

// node_modules/@firebase/component/dist/index.cjs.js
var require_index_cjs = __commonJS({
  "node_modules/@firebase/component/dist/index.cjs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var util = require_index_node_cjs();
    var Component2 = class {
      /**
       *
       * @param name The public service name, e.g. app, auth, firestore, database
       * @param instanceFactory Service factory responsible for creating the public interface
       * @param type whether the service provided by the component is public or private
       */
      constructor(name6, instanceFactory, type) {
        this.name = name6;
        this.instanceFactory = instanceFactory;
        this.type = type;
        this.multipleInstances = false;
        this.serviceProps = {};
        this.instantiationMode = "LAZY";
        this.onInstanceCreated = null;
      }
      setInstantiationMode(mode) {
        this.instantiationMode = mode;
        return this;
      }
      setMultipleInstances(multipleInstances) {
        this.multipleInstances = multipleInstances;
        return this;
      }
      setServiceProps(props) {
        this.serviceProps = props;
        return this;
      }
      setInstanceCreatedCallback(callback) {
        this.onInstanceCreated = callback;
        return this;
      }
    };
    var DEFAULT_ENTRY_NAME3 = "[DEFAULT]";
    var Provider2 = class {
      constructor(name6, container) {
        this.name = name6;
        this.container = container;
        this.component = null;
        this.instances = /* @__PURE__ */ new Map();
        this.instancesDeferred = /* @__PURE__ */ new Map();
        this.instancesOptions = /* @__PURE__ */ new Map();
        this.onInitCallbacks = /* @__PURE__ */ new Map();
      }
      /**
       * @param identifier A provider can provide multiple instances of a service
       * if this.component.multipleInstances is true.
       */
      get(identifier) {
        const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
        if (!this.instancesDeferred.has(normalizedIdentifier)) {
          const deferred = new util.Deferred();
          this.instancesDeferred.set(normalizedIdentifier, deferred);
          if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
            try {
              const instance = this.getOrInitializeService({
                instanceIdentifier: normalizedIdentifier
              });
              if (instance) {
                deferred.resolve(instance);
              }
            } catch (e) {
            }
          }
        }
        return this.instancesDeferred.get(normalizedIdentifier).promise;
      }
      getImmediate(options) {
        const normalizedIdentifier = this.normalizeInstanceIdentifier(options?.identifier);
        const optional = options?.optional ?? false;
        if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
          try {
            return this.getOrInitializeService({
              instanceIdentifier: normalizedIdentifier
            });
          } catch (e) {
            if (optional) {
              return null;
            } else {
              throw e;
            }
          }
        } else {
          if (optional) {
            return null;
          } else {
            throw Error(`Service ${this.name} is not available`);
          }
        }
      }
      getComponent() {
        return this.component;
      }
      setComponent(component) {
        if (component.name !== this.name) {
          throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
        }
        if (this.component) {
          throw Error(`Component for ${this.name} has already been provided`);
        }
        this.component = component;
        if (!this.shouldAutoInitialize()) {
          return;
        }
        if (isComponentEager2(component)) {
          try {
            this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME3 });
          } catch (e) {
          }
        }
        for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
          const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
          try {
            const instance = this.getOrInitializeService({
              instanceIdentifier: normalizedIdentifier
            });
            instanceDeferred.resolve(instance);
          } catch (e) {
          }
        }
      }
      clearInstance(identifier = DEFAULT_ENTRY_NAME3) {
        this.instancesDeferred.delete(identifier);
        this.instancesOptions.delete(identifier);
        this.instances.delete(identifier);
      }
      // app.delete() will call this method on every provider to delete the services
      // TODO: should we mark the provider as deleted?
      async delete() {
        const services = Array.from(this.instances.values());
        await Promise.all([
          ...services.filter((service) => "INTERNAL" in service).map((service) => service.INTERNAL.delete()),
          ...services.filter((service) => "_delete" in service).map((service) => service._delete())
        ]);
      }
      isComponentSet() {
        return this.component != null;
      }
      isInitialized(identifier = DEFAULT_ENTRY_NAME3) {
        return this.instances.has(identifier);
      }
      getOptions(identifier = DEFAULT_ENTRY_NAME3) {
        return this.instancesOptions.get(identifier) || {};
      }
      initialize(opts = {}) {
        const { options = {} } = opts;
        const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
        if (this.isInitialized(normalizedIdentifier)) {
          throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
        }
        if (!this.isComponentSet()) {
          throw Error(`Component ${this.name} has not been registered yet`);
        }
        const instance = this.getOrInitializeService({
          instanceIdentifier: normalizedIdentifier,
          options
        });
        for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
          const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
          if (normalizedIdentifier === normalizedDeferredIdentifier) {
            instanceDeferred.resolve(instance);
          }
        }
        return instance;
      }
      /**
       *
       * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().
       * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.
       *
       * @param identifier An optional instance identifier
       * @returns a function to unregister the callback
       */
      onInit(callback, identifier) {
        const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
        const existingCallbacks = this.onInitCallbacks.get(normalizedIdentifier) ?? /* @__PURE__ */ new Set();
        existingCallbacks.add(callback);
        this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
        const existingInstance = this.instances.get(normalizedIdentifier);
        if (existingInstance) {
          callback(existingInstance, normalizedIdentifier);
        }
        return () => {
          existingCallbacks.delete(callback);
        };
      }
      /**
       * Invoke onInit callbacks synchronously
       * @param instance the service instance`
       */
      invokeOnInitCallbacks(instance, identifier) {
        const callbacks = this.onInitCallbacks.get(identifier);
        if (!callbacks) {
          return;
        }
        for (const callback of callbacks) {
          try {
            callback(instance, identifier);
          } catch {
          }
        }
      }
      getOrInitializeService({ instanceIdentifier, options = {} }) {
        let instance = this.instances.get(instanceIdentifier);
        if (!instance && this.component) {
          instance = this.component.instanceFactory(this.container, {
            instanceIdentifier: normalizeIdentifierForFactory2(instanceIdentifier),
            options
          });
          this.instances.set(instanceIdentifier, instance);
          this.instancesOptions.set(instanceIdentifier, options);
          this.invokeOnInitCallbacks(instance, instanceIdentifier);
          if (this.component.onInstanceCreated) {
            try {
              this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
            } catch {
            }
          }
        }
        return instance || null;
      }
      normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME3) {
        if (this.component) {
          return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME3;
        } else {
          return identifier;
        }
      }
      shouldAutoInitialize() {
        return !!this.component && this.component.instantiationMode !== "EXPLICIT";
      }
    };
    function normalizeIdentifierForFactory2(identifier) {
      return identifier === DEFAULT_ENTRY_NAME3 ? void 0 : identifier;
    }
    function isComponentEager2(component) {
      return component.instantiationMode === "EAGER";
    }
    var ComponentContainer2 = class {
      constructor(name6) {
        this.name = name6;
        this.providers = /* @__PURE__ */ new Map();
      }
      /**
       *
       * @param component Component being added
       * @param overwrite When a component with the same name has already been registered,
       * if overwrite is true: overwrite the existing component with the new component and create a new
       * provider with the new component. It can be useful in tests where you want to use different mocks
       * for different tests.
       * if overwrite is false: throw an exception
       */
      addComponent(component) {
        const provider = this.getProvider(component.name);
        if (provider.isComponentSet()) {
          throw new Error(`Component ${component.name} has already been registered with ${this.name}`);
        }
        provider.setComponent(component);
      }
      addOrOverwriteComponent(component) {
        const provider = this.getProvider(component.name);
        if (provider.isComponentSet()) {
          this.providers.delete(component.name);
        }
        this.addComponent(component);
      }
      /**
       * getProvider provides a type safe interface where it can only be called with a field name
       * present in NameServiceMapping interface.
       *
       * Firebase SDKs providing services should extend NameServiceMapping interface to register
       * themselves.
       */
      getProvider(name6) {
        if (this.providers.has(name6)) {
          return this.providers.get(name6);
        }
        const provider = new Provider2(name6, this);
        this.providers.set(name6, provider);
        return provider;
      }
      getProviders() {
        return Array.from(this.providers.values());
      }
    };
    exports2.Component = Component2;
    exports2.ComponentContainer = ComponentContainer2;
    exports2.Provider = Provider2;
  }
});

// node_modules/@firebase/logger/dist/index.cjs.js
var require_index_cjs2 = __commonJS({
  "node_modules/@firebase/logger/dist/index.cjs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var instances2 = [];
    exports2.LogLevel = void 0;
    (function(LogLevel2) {
      LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
      LogLevel2[LogLevel2["VERBOSE"] = 1] = "VERBOSE";
      LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
      LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
      LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
      LogLevel2[LogLevel2["SILENT"] = 5] = "SILENT";
    })(exports2.LogLevel || (exports2.LogLevel = {}));
    var levelStringToEnum2 = {
      "debug": exports2.LogLevel.DEBUG,
      "verbose": exports2.LogLevel.VERBOSE,
      "info": exports2.LogLevel.INFO,
      "warn": exports2.LogLevel.WARN,
      "error": exports2.LogLevel.ERROR,
      "silent": exports2.LogLevel.SILENT
    };
    var defaultLogLevel2 = exports2.LogLevel.INFO;
    var ConsoleMethod2 = {
      [exports2.LogLevel.DEBUG]: "log",
      [exports2.LogLevel.VERBOSE]: "log",
      [exports2.LogLevel.INFO]: "info",
      [exports2.LogLevel.WARN]: "warn",
      [exports2.LogLevel.ERROR]: "error"
    };
    var defaultLogHandler2 = (instance, logType, ...args) => {
      if (logType < instance.logLevel) {
        return;
      }
      const now = (/* @__PURE__ */ new Date()).toISOString();
      const method = ConsoleMethod2[logType];
      if (method) {
        console[method](`[${now}]  ${instance.name}:`, ...args);
      } else {
        throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
      }
    };
    var Logger2 = class {
      /**
       * Gives you an instance of a Logger to capture messages according to
       * Firebase's logging scheme.
       *
       * @param name The name that the logs will be associated with
       */
      constructor(name6) {
        this.name = name6;
        this._logLevel = defaultLogLevel2;
        this._logHandler = defaultLogHandler2;
        this._userLogHandler = null;
        instances2.push(this);
      }
      get logLevel() {
        return this._logLevel;
      }
      set logLevel(val) {
        if (!(val in exports2.LogLevel)) {
          throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
        }
        this._logLevel = val;
      }
      // Workaround for setter/getter having to be the same type.
      setLogLevel(val) {
        this._logLevel = typeof val === "string" ? levelStringToEnum2[val] : val;
      }
      get logHandler() {
        return this._logHandler;
      }
      set logHandler(val) {
        if (typeof val !== "function") {
          throw new TypeError("Value assigned to `logHandler` must be a function");
        }
        this._logHandler = val;
      }
      get userLogHandler() {
        return this._userLogHandler;
      }
      set userLogHandler(val) {
        this._userLogHandler = val;
      }
      /**
       * The functions below are all based on the `console` interface
       */
      debug(...args) {
        this._userLogHandler && this._userLogHandler(this, exports2.LogLevel.DEBUG, ...args);
        this._logHandler(this, exports2.LogLevel.DEBUG, ...args);
      }
      log(...args) {
        this._userLogHandler && this._userLogHandler(this, exports2.LogLevel.VERBOSE, ...args);
        this._logHandler(this, exports2.LogLevel.VERBOSE, ...args);
      }
      info(...args) {
        this._userLogHandler && this._userLogHandler(this, exports2.LogLevel.INFO, ...args);
        this._logHandler(this, exports2.LogLevel.INFO, ...args);
      }
      warn(...args) {
        this._userLogHandler && this._userLogHandler(this, exports2.LogLevel.WARN, ...args);
        this._logHandler(this, exports2.LogLevel.WARN, ...args);
      }
      error(...args) {
        this._userLogHandler && this._userLogHandler(this, exports2.LogLevel.ERROR, ...args);
        this._logHandler(this, exports2.LogLevel.ERROR, ...args);
      }
    };
    function setLogLevel2(level) {
      instances2.forEach((inst) => {
        inst.setLogLevel(level);
      });
    }
    function setUserLogHandler2(logCallback, options) {
      for (const instance of instances2) {
        let customLogLevel = null;
        if (options && options.level) {
          customLogLevel = levelStringToEnum2[options.level];
        }
        if (logCallback === null) {
          instance.userLogHandler = null;
        } else {
          instance.userLogHandler = (instance2, level, ...args) => {
            const message = args.map((arg) => {
              if (arg == null) {
                return null;
              } else if (typeof arg === "string") {
                return arg;
              } else if (typeof arg === "number" || typeof arg === "boolean") {
                return arg.toString();
              } else if (arg instanceof Error) {
                return arg.message;
              } else {
                try {
                  return JSON.stringify(arg);
                } catch (ignored) {
                  return null;
                }
              }
            }).filter((arg) => arg).join(" ");
            if (level >= (customLogLevel ?? instance2.logLevel)) {
              logCallback({
                level: exports2.LogLevel[level].toLowerCase(),
                message,
                args,
                type: instance2.name
              });
            }
          };
        }
      }
    }
    exports2.Logger = Logger2;
    exports2.setLogLevel = setLogLevel2;
    exports2.setUserLogHandler = setUserLogHandler2;
  }
});

// node_modules/@firebase/app/dist/index.cjs.js
var require_index_cjs3 = __commonJS({
  "node_modules/@firebase/app/dist/index.cjs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var component = require_index_cjs();
    var logger$1 = require_index_cjs2();
    var util = require_index_node_cjs();
    var idb = (init_build(), __toCommonJS(build_exports));
    var PlatformLoggerServiceImpl2 = class {
      constructor(container) {
        this.container = container;
      }
      // In initial implementation, this will be called by installations on
      // auth token refresh, and installations will send this string.
      getPlatformInfoString() {
        const providers = this.container.getProviders();
        return providers.map((provider) => {
          if (isVersionServiceProvider2(provider)) {
            const service = provider.getImmediate();
            return `${service.library}/${service.version}`;
          } else {
            return null;
          }
        }).filter((logString) => logString).join(" ");
      }
    };
    function isVersionServiceProvider2(provider) {
      const component2 = provider.getComponent();
      return component2?.type === "VERSION";
    }
    var name$q2 = "@firebase/app";
    var version$12 = "0.14.5";
    var logger2 = new logger$1.Logger("@firebase/app");
    var name$p2 = "@firebase/app-compat";
    var name$o2 = "@firebase/analytics-compat";
    var name$n2 = "@firebase/analytics";
    var name$m2 = "@firebase/app-check-compat";
    var name$l2 = "@firebase/app-check";
    var name$k2 = "@firebase/auth";
    var name$j2 = "@firebase/auth-compat";
    var name$i2 = "@firebase/database";
    var name$h2 = "@firebase/data-connect";
    var name$g2 = "@firebase/database-compat";
    var name$f2 = "@firebase/functions";
    var name$e2 = "@firebase/functions-compat";
    var name$d2 = "@firebase/installations";
    var name$c2 = "@firebase/installations-compat";
    var name$b2 = "@firebase/messaging";
    var name$a2 = "@firebase/messaging-compat";
    var name$92 = "@firebase/performance";
    var name$82 = "@firebase/performance-compat";
    var name$72 = "@firebase/remote-config";
    var name$62 = "@firebase/remote-config-compat";
    var name$52 = "@firebase/storage";
    var name$42 = "@firebase/storage-compat";
    var name$32 = "@firebase/firestore";
    var name$22 = "@firebase/ai";
    var name$12 = "@firebase/firestore-compat";
    var name6 = "firebase";
    var version6 = "12.5.0";
    var DEFAULT_ENTRY_NAME3 = "[DEFAULT]";
    var PLATFORM_LOG_STRING2 = {
      [name$q2]: "fire-core",
      [name$p2]: "fire-core-compat",
      [name$n2]: "fire-analytics",
      [name$o2]: "fire-analytics-compat",
      [name$l2]: "fire-app-check",
      [name$m2]: "fire-app-check-compat",
      [name$k2]: "fire-auth",
      [name$j2]: "fire-auth-compat",
      [name$i2]: "fire-rtdb",
      [name$h2]: "fire-data-connect",
      [name$g2]: "fire-rtdb-compat",
      [name$f2]: "fire-fn",
      [name$e2]: "fire-fn-compat",
      [name$d2]: "fire-iid",
      [name$c2]: "fire-iid-compat",
      [name$b2]: "fire-fcm",
      [name$a2]: "fire-fcm-compat",
      [name$92]: "fire-perf",
      [name$82]: "fire-perf-compat",
      [name$72]: "fire-rc",
      [name$62]: "fire-rc-compat",
      [name$52]: "fire-gcs",
      [name$42]: "fire-gcs-compat",
      [name$32]: "fire-fst",
      [name$12]: "fire-fst-compat",
      [name$22]: "fire-vertex",
      "fire-js": "fire-js",
      // Platform identifier for JS SDK.
      [name6]: "fire-js-all"
    };
    var _apps2 = /* @__PURE__ */ new Map();
    var _serverApps2 = /* @__PURE__ */ new Map();
    var _components2 = /* @__PURE__ */ new Map();
    function _addComponent2(app2, component2) {
      try {
        app2.container.addComponent(component2);
      } catch (e) {
        logger2.debug(`Component ${component2.name} failed to register with FirebaseApp ${app2.name}`, e);
      }
    }
    function _addOrOverwriteComponent(app2, component2) {
      app2.container.addOrOverwriteComponent(component2);
    }
    function _registerComponent2(component2) {
      const componentName = component2.name;
      if (_components2.has(componentName)) {
        logger2.debug(`There were multiple attempts to register component ${componentName}.`);
        return false;
      }
      _components2.set(componentName, component2);
      for (const app2 of _apps2.values()) {
        _addComponent2(app2, component2);
      }
      for (const serverApp of _serverApps2.values()) {
        _addComponent2(serverApp, component2);
      }
      return true;
    }
    function _getProvider2(app2, name7) {
      const heartbeatController = app2.container.getProvider("heartbeat").getImmediate({ optional: true });
      if (heartbeatController) {
        void heartbeatController.triggerHeartbeat();
      }
      return app2.container.getProvider(name7);
    }
    function _removeServiceInstance(app2, name7, instanceIdentifier = DEFAULT_ENTRY_NAME3) {
      _getProvider2(app2, name7).clearInstance(instanceIdentifier);
    }
    function _isFirebaseApp(obj) {
      return obj.options !== void 0;
    }
    function _isFirebaseServerAppSettings(obj) {
      if (_isFirebaseApp(obj)) {
        return false;
      }
      return "authIdToken" in obj || "appCheckToken" in obj || "releaseOnDeref" in obj || "automaticDataCollectionEnabled" in obj;
    }
    function _isFirebaseServerApp2(obj) {
      if (obj === null || obj === void 0) {
        return false;
      }
      return obj.settings !== void 0;
    }
    function _clearComponents() {
      _components2.clear();
    }
    var ERRORS2 = {
      [
        "no-app"
        /* AppError.NO_APP */
      ]: "No Firebase App '{$appName}' has been created - call initializeApp() first",
      [
        "bad-app-name"
        /* AppError.BAD_APP_NAME */
      ]: "Illegal App name: '{$appName}'",
      [
        "duplicate-app"
        /* AppError.DUPLICATE_APP */
      ]: "Firebase App named '{$appName}' already exists with different options or config",
      [
        "app-deleted"
        /* AppError.APP_DELETED */
      ]: "Firebase App named '{$appName}' already deleted",
      [
        "server-app-deleted"
        /* AppError.SERVER_APP_DELETED */
      ]: "Firebase Server App has been deleted",
      [
        "no-options"
        /* AppError.NO_OPTIONS */
      ]: "Need to provide options, when not being deployed to hosting via source.",
      [
        "invalid-app-argument"
        /* AppError.INVALID_APP_ARGUMENT */
      ]: "firebase.{$appName}() takes either no argument or a Firebase App instance.",
      [
        "invalid-log-argument"
        /* AppError.INVALID_LOG_ARGUMENT */
      ]: "First argument to `onLog` must be null or a function.",
      [
        "idb-open"
        /* AppError.IDB_OPEN */
      ]: "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "idb-get"
        /* AppError.IDB_GET */
      ]: "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "idb-set"
        /* AppError.IDB_WRITE */
      ]: "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "idb-delete"
        /* AppError.IDB_DELETE */
      ]: "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.",
      [
        "finalization-registry-not-supported"
        /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */
      ]: "FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.",
      [
        "invalid-server-app-environment"
        /* AppError.INVALID_SERVER_APP_ENVIRONMENT */
      ]: "FirebaseServerApp is not for use in browser environments."
    };
    var ERROR_FACTORY2 = new util.ErrorFactory("app", "Firebase", ERRORS2);
    var FirebaseAppImpl2 = class {
      constructor(options, config, container) {
        this._isDeleted = false;
        this._options = { ...options };
        this._config = { ...config };
        this._name = config.name;
        this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;
        this._container = container;
        this.container.addComponent(new component.Component(
          "app",
          () => this,
          "PUBLIC"
          /* ComponentType.PUBLIC */
        ));
      }
      get automaticDataCollectionEnabled() {
        this.checkDestroyed();
        return this._automaticDataCollectionEnabled;
      }
      set automaticDataCollectionEnabled(val) {
        this.checkDestroyed();
        this._automaticDataCollectionEnabled = val;
      }
      get name() {
        this.checkDestroyed();
        return this._name;
      }
      get options() {
        this.checkDestroyed();
        return this._options;
      }
      get config() {
        this.checkDestroyed();
        return this._config;
      }
      get container() {
        return this._container;
      }
      get isDeleted() {
        return this._isDeleted;
      }
      set isDeleted(val) {
        this._isDeleted = val;
      }
      /**
       * This function will throw an Error if the App has already been deleted -
       * use before performing API actions on the App.
       */
      checkDestroyed() {
        if (this.isDeleted) {
          throw ERROR_FACTORY2.create("app-deleted", { appName: this._name });
        }
      }
    };
    function validateTokenTTL(base64Token, tokenName) {
      const secondPart = util.base64Decode(base64Token.split(".")[1]);
      if (secondPart === null) {
        console.error(`FirebaseServerApp ${tokenName} is invalid: second part could not be parsed.`);
        return;
      }
      const expClaim = JSON.parse(secondPart).exp;
      if (expClaim === void 0) {
        console.error(`FirebaseServerApp ${tokenName} is invalid: expiration claim could not be parsed`);
        return;
      }
      const exp = JSON.parse(secondPart).exp * 1e3;
      const now = (/* @__PURE__ */ new Date()).getTime();
      const diff = exp - now;
      if (diff <= 0) {
        console.error(`FirebaseServerApp ${tokenName} is invalid: the token has expired.`);
      }
    }
    var FirebaseServerAppImpl = class extends FirebaseAppImpl2 {
      constructor(options, serverConfig, name7, container) {
        const automaticDataCollectionEnabled = serverConfig.automaticDataCollectionEnabled !== void 0 ? serverConfig.automaticDataCollectionEnabled : true;
        const config = {
          name: name7,
          automaticDataCollectionEnabled
        };
        if (options.apiKey !== void 0) {
          super(options, config, container);
        } else {
          const appImpl = options;
          super(appImpl.options, config, container);
        }
        this._serverConfig = {
          automaticDataCollectionEnabled,
          ...serverConfig
        };
        if (this._serverConfig.authIdToken) {
          validateTokenTTL(this._serverConfig.authIdToken, "authIdToken");
        }
        if (this._serverConfig.appCheckToken) {
          validateTokenTTL(this._serverConfig.appCheckToken, "appCheckToken");
        }
        this._finalizationRegistry = null;
        if (typeof FinalizationRegistry !== "undefined") {
          this._finalizationRegistry = new FinalizationRegistry(() => {
            this.automaticCleanup();
          });
        }
        this._refCount = 0;
        this.incRefCount(this._serverConfig.releaseOnDeref);
        this._serverConfig.releaseOnDeref = void 0;
        serverConfig.releaseOnDeref = void 0;
        registerVersion2(name$q2, version$12, "serverapp");
      }
      toJSON() {
        return void 0;
      }
      get refCount() {
        return this._refCount;
      }
      // Increment the reference count of this server app. If an object is provided, register it
      // with the finalization registry.
      incRefCount(obj) {
        if (this.isDeleted) {
          return;
        }
        this._refCount++;
        if (obj !== void 0 && this._finalizationRegistry !== null) {
          this._finalizationRegistry.register(obj, this);
        }
      }
      // Decrement the reference count.
      decRefCount() {
        if (this.isDeleted) {
          return 0;
        }
        return --this._refCount;
      }
      // Invoked by the FinalizationRegistry callback to note that this app should go through its
      // reference counts and delete itself if no reference count remain. The coordinating logic that
      // handles this is in deleteApp(...).
      automaticCleanup() {
        void deleteApp(this);
      }
      get settings() {
        this.checkDestroyed();
        return this._serverConfig;
      }
      /**
       * This function will throw an Error if the App has already been deleted -
       * use before performing API actions on the App.
       */
      checkDestroyed() {
        if (this.isDeleted) {
          throw ERROR_FACTORY2.create(
            "server-app-deleted"
            /* AppError.SERVER_APP_DELETED */
          );
        }
      }
    };
    var SDK_VERSION2 = version6;
    function initializeApp2(_options, rawConfig = {}) {
      let options = _options;
      if (typeof rawConfig !== "object") {
        const name8 = rawConfig;
        rawConfig = { name: name8 };
      }
      const config = {
        name: DEFAULT_ENTRY_NAME3,
        automaticDataCollectionEnabled: true,
        ...rawConfig
      };
      const name7 = config.name;
      if (typeof name7 !== "string" || !name7) {
        throw ERROR_FACTORY2.create("bad-app-name", {
          appName: String(name7)
        });
      }
      options || (options = util.getDefaultAppConfig());
      if (!options) {
        throw ERROR_FACTORY2.create(
          "no-options"
          /* AppError.NO_OPTIONS */
        );
      }
      const existingApp = _apps2.get(name7);
      if (existingApp) {
        if (util.deepEqual(options, existingApp.options) && util.deepEqual(config, existingApp.config)) {
          return existingApp;
        } else {
          throw ERROR_FACTORY2.create("duplicate-app", { appName: name7 });
        }
      }
      const container = new component.ComponentContainer(name7);
      for (const component2 of _components2.values()) {
        container.addComponent(component2);
      }
      const newApp = new FirebaseAppImpl2(options, config, container);
      _apps2.set(name7, newApp);
      return newApp;
    }
    function initializeServerApp(_options, _serverAppConfig = {}) {
      if (util.isBrowser() && !util.isWebWorker()) {
        throw ERROR_FACTORY2.create(
          "invalid-server-app-environment"
          /* AppError.INVALID_SERVER_APP_ENVIRONMENT */
        );
      }
      let firebaseOptions;
      let serverAppSettings = _serverAppConfig || {};
      if (_options) {
        if (_isFirebaseApp(_options)) {
          firebaseOptions = _options.options;
        } else if (_isFirebaseServerAppSettings(_options)) {
          serverAppSettings = _options;
        } else {
          firebaseOptions = _options;
        }
      }
      if (serverAppSettings.automaticDataCollectionEnabled === void 0) {
        serverAppSettings.automaticDataCollectionEnabled = true;
      }
      firebaseOptions || (firebaseOptions = util.getDefaultAppConfig());
      if (!firebaseOptions) {
        throw ERROR_FACTORY2.create(
          "no-options"
          /* AppError.NO_OPTIONS */
        );
      }
      const nameObj = {
        ...serverAppSettings,
        ...firebaseOptions
      };
      if (nameObj.releaseOnDeref !== void 0) {
        delete nameObj.releaseOnDeref;
      }
      const hashCode = (s) => {
        return [...s].reduce((hash, c) => Math.imul(31, hash) + c.charCodeAt(0) | 0, 0);
      };
      if (serverAppSettings.releaseOnDeref !== void 0) {
        if (typeof FinalizationRegistry === "undefined") {
          throw ERROR_FACTORY2.create("finalization-registry-not-supported", {});
        }
      }
      const nameString = "" + hashCode(JSON.stringify(nameObj));
      const existingApp = _serverApps2.get(nameString);
      if (existingApp) {
        existingApp.incRefCount(serverAppSettings.releaseOnDeref);
        return existingApp;
      }
      const container = new component.ComponentContainer(nameString);
      for (const component2 of _components2.values()) {
        container.addComponent(component2);
      }
      const newApp = new FirebaseServerAppImpl(firebaseOptions, serverAppSettings, nameString, container);
      _serverApps2.set(nameString, newApp);
      return newApp;
    }
    function getApp2(name7 = DEFAULT_ENTRY_NAME3) {
      const app2 = _apps2.get(name7);
      if (!app2 && name7 === DEFAULT_ENTRY_NAME3 && util.getDefaultAppConfig()) {
        return initializeApp2();
      }
      if (!app2) {
        throw ERROR_FACTORY2.create("no-app", { appName: name7 });
      }
      return app2;
    }
    function getApps() {
      return Array.from(_apps2.values());
    }
    async function deleteApp(app2) {
      let cleanupProviders = false;
      const name7 = app2.name;
      if (_apps2.has(name7)) {
        cleanupProviders = true;
        _apps2.delete(name7);
      } else if (_serverApps2.has(name7)) {
        const firebaseServerApp = app2;
        if (firebaseServerApp.decRefCount() <= 0) {
          _serverApps2.delete(name7);
          cleanupProviders = true;
        }
      }
      if (cleanupProviders) {
        await Promise.all(app2.container.getProviders().map((provider) => provider.delete()));
        app2.isDeleted = true;
      }
    }
    function registerVersion2(libraryKeyOrName, version7, variant) {
      let library = PLATFORM_LOG_STRING2[libraryKeyOrName] ?? libraryKeyOrName;
      if (variant) {
        library += `-${variant}`;
      }
      const libraryMismatch = library.match(/\s|\//);
      const versionMismatch = version7.match(/\s|\//);
      if (libraryMismatch || versionMismatch) {
        const warning = [
          `Unable to register library "${library}" with version "${version7}":`
        ];
        if (libraryMismatch) {
          warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
        }
        if (libraryMismatch && versionMismatch) {
          warning.push("and");
        }
        if (versionMismatch) {
          warning.push(`version name "${version7}" contains illegal characters (whitespace or "/")`);
        }
        logger2.warn(warning.join(" "));
        return;
      }
      _registerComponent2(new component.Component(
        `${library}-version`,
        () => ({ library, version: version7 }),
        "VERSION"
        /* ComponentType.VERSION */
      ));
    }
    function onLog(logCallback, options) {
      if (logCallback !== null && typeof logCallback !== "function") {
        throw ERROR_FACTORY2.create(
          "invalid-log-argument"
          /* AppError.INVALID_LOG_ARGUMENT */
        );
      }
      logger$1.setUserLogHandler(logCallback, options);
    }
    function setLogLevel2(logLevel) {
      logger$1.setLogLevel(logLevel);
    }
    var DB_NAME2 = "firebase-heartbeat-database";
    var DB_VERSION2 = 1;
    var STORE_NAME2 = "firebase-heartbeat-store";
    var dbPromise2 = null;
    function getDbPromise2() {
      if (!dbPromise2) {
        dbPromise2 = idb.openDB(DB_NAME2, DB_VERSION2, {
          upgrade: (db, oldVersion) => {
            switch (oldVersion) {
              case 0:
                try {
                  db.createObjectStore(STORE_NAME2);
                } catch (e) {
                  console.warn(e);
                }
            }
          }
        }).catch((e) => {
          throw ERROR_FACTORY2.create("idb-open", {
            originalErrorMessage: e.message
          });
        });
      }
      return dbPromise2;
    }
    async function readHeartbeatsFromIndexedDB2(app2) {
      try {
        const db = await getDbPromise2();
        const tx = db.transaction(STORE_NAME2);
        const result = await tx.objectStore(STORE_NAME2).get(computeKey2(app2));
        await tx.done;
        return result;
      } catch (e) {
        if (e instanceof util.FirebaseError) {
          logger2.warn(e.message);
        } else {
          const idbGetError = ERROR_FACTORY2.create("idb-get", {
            originalErrorMessage: e?.message
          });
          logger2.warn(idbGetError.message);
        }
      }
    }
    async function writeHeartbeatsToIndexedDB2(app2, heartbeatObject) {
      try {
        const db = await getDbPromise2();
        const tx = db.transaction(STORE_NAME2, "readwrite");
        const objectStore = tx.objectStore(STORE_NAME2);
        await objectStore.put(heartbeatObject, computeKey2(app2));
        await tx.done;
      } catch (e) {
        if (e instanceof util.FirebaseError) {
          logger2.warn(e.message);
        } else {
          const idbGetError = ERROR_FACTORY2.create("idb-set", {
            originalErrorMessage: e?.message
          });
          logger2.warn(idbGetError.message);
        }
      }
    }
    function computeKey2(app2) {
      return `${app2.name}!${app2.options.appId}`;
    }
    var MAX_HEADER_BYTES2 = 1024;
    var MAX_NUM_STORED_HEARTBEATS2 = 30;
    var HeartbeatServiceImpl2 = class {
      constructor(container) {
        this.container = container;
        this._heartbeatsCache = null;
        const app2 = this.container.getProvider("app").getImmediate();
        this._storage = new HeartbeatStorageImpl2(app2);
        this._heartbeatsCachePromise = this._storage.read().then((result) => {
          this._heartbeatsCache = result;
          return result;
        });
      }
      /**
       * Called to report a heartbeat. The function will generate
       * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
       * to IndexedDB.
       * Note that we only store one heartbeat per day. So if a heartbeat for today is
       * already logged, subsequent calls to this function in the same day will be ignored.
       */
      async triggerHeartbeat() {
        try {
          const platformLogger = this.container.getProvider("platform-logger").getImmediate();
          const agent = platformLogger.getPlatformInfoString();
          const date = getUTCDateString2();
          if (this._heartbeatsCache?.heartbeats == null) {
            this._heartbeatsCache = await this._heartbeatsCachePromise;
            if (this._heartbeatsCache?.heartbeats == null) {
              return;
            }
          }
          if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some((singleDateHeartbeat) => singleDateHeartbeat.date === date)) {
            return;
          } else {
            this._heartbeatsCache.heartbeats.push({ date, agent });
            if (this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS2) {
              const earliestHeartbeatIdx = getEarliestHeartbeatIdx2(this._heartbeatsCache.heartbeats);
              this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);
            }
          }
          return this._storage.overwrite(this._heartbeatsCache);
        } catch (e) {
          logger2.warn(e);
        }
      }
      /**
       * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
       * It also clears all heartbeats from memory as well as in IndexedDB.
       *
       * NOTE: Consuming product SDKs should not send the header if this method
       * returns an empty string.
       */
      async getHeartbeatsHeader() {
        try {
          if (this._heartbeatsCache === null) {
            await this._heartbeatsCachePromise;
          }
          if (this._heartbeatsCache?.heartbeats == null || this._heartbeatsCache.heartbeats.length === 0) {
            return "";
          }
          const date = getUTCDateString2();
          const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader2(this._heartbeatsCache.heartbeats);
          const headerString = util.base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
          this._heartbeatsCache.lastSentHeartbeatDate = date;
          if (unsentEntries.length > 0) {
            this._heartbeatsCache.heartbeats = unsentEntries;
            await this._storage.overwrite(this._heartbeatsCache);
          } else {
            this._heartbeatsCache.heartbeats = [];
            void this._storage.overwrite(this._heartbeatsCache);
          }
          return headerString;
        } catch (e) {
          logger2.warn(e);
          return "";
        }
      }
    };
    function getUTCDateString2() {
      const today = /* @__PURE__ */ new Date();
      return today.toISOString().substring(0, 10);
    }
    function extractHeartbeatsForHeader2(heartbeatsCache, maxSize = MAX_HEADER_BYTES2) {
      const heartbeatsToSend = [];
      let unsentEntries = heartbeatsCache.slice();
      for (const singleDateHeartbeat of heartbeatsCache) {
        const heartbeatEntry = heartbeatsToSend.find((hb) => hb.agent === singleDateHeartbeat.agent);
        if (!heartbeatEntry) {
          heartbeatsToSend.push({
            agent: singleDateHeartbeat.agent,
            dates: [singleDateHeartbeat.date]
          });
          if (countBytes2(heartbeatsToSend) > maxSize) {
            heartbeatsToSend.pop();
            break;
          }
        } else {
          heartbeatEntry.dates.push(singleDateHeartbeat.date);
          if (countBytes2(heartbeatsToSend) > maxSize) {
            heartbeatEntry.dates.pop();
            break;
          }
        }
        unsentEntries = unsentEntries.slice(1);
      }
      return {
        heartbeatsToSend,
        unsentEntries
      };
    }
    var HeartbeatStorageImpl2 = class {
      constructor(app2) {
        this.app = app2;
        this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
      }
      async runIndexedDBEnvironmentCheck() {
        if (!util.isIndexedDBAvailable()) {
          return false;
        } else {
          return util.validateIndexedDBOpenable().then(() => true).catch(() => false);
        }
      }
      /**
       * Read all heartbeats.
       */
      async read() {
        const canUseIndexedDB = await this._canUseIndexedDBPromise;
        if (!canUseIndexedDB) {
          return { heartbeats: [] };
        } else {
          const idbHeartbeatObject = await readHeartbeatsFromIndexedDB2(this.app);
          if (idbHeartbeatObject?.heartbeats) {
            return idbHeartbeatObject;
          } else {
            return { heartbeats: [] };
          }
        }
      }
      // overwrite the storage with the provided heartbeats
      async overwrite(heartbeatsObject) {
        const canUseIndexedDB = await this._canUseIndexedDBPromise;
        if (!canUseIndexedDB) {
          return;
        } else {
          const existingHeartbeatsObject = await this.read();
          return writeHeartbeatsToIndexedDB2(this.app, {
            lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ?? existingHeartbeatsObject.lastSentHeartbeatDate,
            heartbeats: heartbeatsObject.heartbeats
          });
        }
      }
      // add heartbeats
      async add(heartbeatsObject) {
        const canUseIndexedDB = await this._canUseIndexedDBPromise;
        if (!canUseIndexedDB) {
          return;
        } else {
          const existingHeartbeatsObject = await this.read();
          return writeHeartbeatsToIndexedDB2(this.app, {
            lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ?? existingHeartbeatsObject.lastSentHeartbeatDate,
            heartbeats: [
              ...existingHeartbeatsObject.heartbeats,
              ...heartbeatsObject.heartbeats
            ]
          });
        }
      }
    };
    function countBytes2(heartbeatsCache) {
      return util.base64urlEncodeWithoutPadding(
        // heartbeatsCache wrapper properties
        JSON.stringify({ version: 2, heartbeats: heartbeatsCache })
      ).length;
    }
    function getEarliestHeartbeatIdx2(heartbeats) {
      if (heartbeats.length === 0) {
        return -1;
      }
      let earliestHeartbeatIdx = 0;
      let earliestHeartbeatDate = heartbeats[0].date;
      for (let i = 1; i < heartbeats.length; i++) {
        if (heartbeats[i].date < earliestHeartbeatDate) {
          earliestHeartbeatDate = heartbeats[i].date;
          earliestHeartbeatIdx = i;
        }
      }
      return earliestHeartbeatIdx;
    }
    function registerCoreComponents2(variant) {
      _registerComponent2(new component.Component(
        "platform-logger",
        (container) => new PlatformLoggerServiceImpl2(container),
        "PRIVATE"
        /* ComponentType.PRIVATE */
      ));
      _registerComponent2(new component.Component(
        "heartbeat",
        (container) => new HeartbeatServiceImpl2(container),
        "PRIVATE"
        /* ComponentType.PRIVATE */
      ));
      registerVersion2(name$q2, version$12, variant);
      registerVersion2(name$q2, version$12, "cjs2020");
      registerVersion2("fire-js", "");
    }
    registerCoreComponents2("node");
    Object.defineProperty(exports2, "FirebaseError", {
      enumerable: true,
      get: function() {
        return util.FirebaseError;
      }
    });
    exports2.SDK_VERSION = SDK_VERSION2;
    exports2._DEFAULT_ENTRY_NAME = DEFAULT_ENTRY_NAME3;
    exports2._addComponent = _addComponent2;
    exports2._addOrOverwriteComponent = _addOrOverwriteComponent;
    exports2._apps = _apps2;
    exports2._clearComponents = _clearComponents;
    exports2._components = _components2;
    exports2._getProvider = _getProvider2;
    exports2._isFirebaseApp = _isFirebaseApp;
    exports2._isFirebaseServerApp = _isFirebaseServerApp2;
    exports2._isFirebaseServerAppSettings = _isFirebaseServerAppSettings;
    exports2._registerComponent = _registerComponent2;
    exports2._removeServiceInstance = _removeServiceInstance;
    exports2._serverApps = _serverApps2;
    exports2.deleteApp = deleteApp;
    exports2.getApp = getApp2;
    exports2.getApps = getApps;
    exports2.initializeApp = initializeApp2;
    exports2.initializeServerApp = initializeServerApp;
    exports2.onLog = onLog;
    exports2.registerVersion = registerVersion2;
    exports2.setLogLevel = setLogLevel2;
  }
});

// node_modules/@firebase/auth/dist/node/totp-50d5d5dd.js
var require_totp_50d5d5dd = __commonJS({
  "node_modules/@firebase/auth/dist/node/totp-50d5d5dd.js"(exports2) {
    "use strict";
    var app2 = require_index_cjs3();
    var util = require_index_node_cjs();
    var component = require_index_cjs();
    var logger2 = require_index_cjs2();
    var FactorId2 = {
      /** Phone as second factor */
      PHONE: "phone",
      TOTP: "totp"
    };
    var ProviderId2 = {
      /** Facebook provider ID */
      FACEBOOK: "facebook.com",
      /** GitHub provider ID */
      GITHUB: "github.com",
      /** Google provider ID */
      GOOGLE: "google.com",
      /** Password provider */
      PASSWORD: "password",
      /** Phone provider */
      PHONE: "phone",
      /** Twitter provider ID */
      TWITTER: "twitter.com"
    };
    var SignInMethod2 = {
      /** Email link sign in method */
      EMAIL_LINK: "emailLink",
      /** Email/password sign in method */
      EMAIL_PASSWORD: "password",
      /** Facebook sign in method */
      FACEBOOK: "facebook.com",
      /** GitHub sign in method */
      GITHUB: "github.com",
      /** Google sign in method */
      GOOGLE: "google.com",
      /** Phone sign in method */
      PHONE: "phone",
      /** Twitter sign in method */
      TWITTER: "twitter.com"
    };
    var OperationType2 = {
      /** Operation involving linking an additional provider to an already signed-in user. */
      LINK: "link",
      /** Operation involving using a provider to reauthenticate an already signed-in user. */
      REAUTHENTICATE: "reauthenticate",
      /** Operation involving signing in a user. */
      SIGN_IN: "signIn"
    };
    var ActionCodeOperation2 = {
      /** The email link sign-in action. */
      EMAIL_SIGNIN: "EMAIL_SIGNIN",
      /** The password reset action. */
      PASSWORD_RESET: "PASSWORD_RESET",
      /** The email revocation action. */
      RECOVER_EMAIL: "RECOVER_EMAIL",
      /** The revert second factor addition email action. */
      REVERT_SECOND_FACTOR_ADDITION: "REVERT_SECOND_FACTOR_ADDITION",
      /** The revert second factor addition email action. */
      VERIFY_AND_CHANGE_EMAIL: "VERIFY_AND_CHANGE_EMAIL",
      /** The email verification action. */
      VERIFY_EMAIL: "VERIFY_EMAIL"
    };
    function _debugErrorMap2() {
      return {
        [
          "admin-restricted-operation"
          /* AuthErrorCode.ADMIN_ONLY_OPERATION */
        ]: "This operation is restricted to administrators only.",
        [
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        ]: "",
        [
          "app-not-authorized"
          /* AuthErrorCode.APP_NOT_AUTHORIZED */
        ]: "This app, identified by the domain where it's hosted, is not authorized to use Firebase Authentication with the provided API key. Review your key configuration in the Google API console.",
        [
          "app-not-installed"
          /* AuthErrorCode.APP_NOT_INSTALLED */
        ]: "The requested mobile application corresponding to the identifier (Android package name or iOS bundle ID) provided is not installed on this device.",
        [
          "captcha-check-failed"
          /* AuthErrorCode.CAPTCHA_CHECK_FAILED */
        ]: "The reCAPTCHA response token provided is either invalid, expired, already used or the domain associated with it does not match the list of whitelisted domains.",
        [
          "code-expired"
          /* AuthErrorCode.CODE_EXPIRED */
        ]: "The SMS code has expired. Please re-send the verification code to try again.",
        [
          "cordova-not-ready"
          /* AuthErrorCode.CORDOVA_NOT_READY */
        ]: "Cordova framework is not ready.",
        [
          "cors-unsupported"
          /* AuthErrorCode.CORS_UNSUPPORTED */
        ]: "This browser is not supported.",
        [
          "credential-already-in-use"
          /* AuthErrorCode.CREDENTIAL_ALREADY_IN_USE */
        ]: "This credential is already associated with a different user account.",
        [
          "custom-token-mismatch"
          /* AuthErrorCode.CREDENTIAL_MISMATCH */
        ]: "The custom token corresponds to a different audience.",
        [
          "requires-recent-login"
          /* AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */
        ]: "This operation is sensitive and requires recent authentication. Log in again before retrying this request.",
        [
          "dependent-sdk-initialized-before-auth"
          /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
        ]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK.",
        [
          "dynamic-link-not-activated"
          /* AuthErrorCode.DYNAMIC_LINK_NOT_ACTIVATED */
        ]: "Please activate Dynamic Links in the Firebase Console and agree to the terms and conditions.",
        [
          "email-change-needs-verification"
          /* AuthErrorCode.EMAIL_CHANGE_NEEDS_VERIFICATION */
        ]: "Multi-factor users must always have a verified email.",
        [
          "email-already-in-use"
          /* AuthErrorCode.EMAIL_EXISTS */
        ]: "The email address is already in use by another account.",
        [
          "emulator-config-failed"
          /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
        ]: 'Auth instance has already been used to make a network call. Auth can no longer be configured to use the emulator. Try calling "connectAuthEmulator()" sooner.',
        [
          "expired-action-code"
          /* AuthErrorCode.EXPIRED_OOB_CODE */
        ]: "The action code has expired.",
        [
          "cancelled-popup-request"
          /* AuthErrorCode.EXPIRED_POPUP_REQUEST */
        ]: "This operation has been cancelled due to another conflicting popup being opened.",
        [
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        ]: "An internal AuthError has occurred.",
        [
          "invalid-app-credential"
          /* AuthErrorCode.INVALID_APP_CREDENTIAL */
        ]: "The phone verification request contains an invalid application verifier. The reCAPTCHA token response is either invalid or expired.",
        [
          "invalid-app-id"
          /* AuthErrorCode.INVALID_APP_ID */
        ]: "The mobile app identifier is not registered for the current project.",
        [
          "invalid-user-token"
          /* AuthErrorCode.INVALID_AUTH */
        ]: "This user's credential isn't valid for this project. This can happen if the user's token has been tampered with, or if the user isn't for the project associated with this API key.",
        [
          "invalid-auth-event"
          /* AuthErrorCode.INVALID_AUTH_EVENT */
        ]: "An internal AuthError has occurred.",
        [
          "invalid-verification-code"
          /* AuthErrorCode.INVALID_CODE */
        ]: "The SMS verification code used to create the phone auth credential is invalid. Please resend the verification code sms and be sure to use the verification code provided by the user.",
        [
          "invalid-continue-uri"
          /* AuthErrorCode.INVALID_CONTINUE_URI */
        ]: "The continue URL provided in the request is invalid.",
        [
          "invalid-cordova-configuration"
          /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */
        ]: "The following Cordova plugins must be installed to enable OAuth sign-in: cordova-plugin-buildinfo, cordova-universal-links-plugin, cordova-plugin-browsertab, cordova-plugin-inappbrowser and cordova-plugin-customurlscheme.",
        [
          "invalid-custom-token"
          /* AuthErrorCode.INVALID_CUSTOM_TOKEN */
        ]: "The custom token format is incorrect. Please check the documentation.",
        [
          "invalid-dynamic-link-domain"
          /* AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN */
        ]: "The provided dynamic link domain is not configured or authorized for the current project.",
        [
          "invalid-email"
          /* AuthErrorCode.INVALID_EMAIL */
        ]: "The email address is badly formatted.",
        [
          "invalid-emulator-scheme"
          /* AuthErrorCode.INVALID_EMULATOR_SCHEME */
        ]: "Emulator URL must start with a valid scheme (http:// or https://).",
        [
          "invalid-api-key"
          /* AuthErrorCode.INVALID_API_KEY */
        ]: "Your API key is invalid, please check you have copied it correctly.",
        [
          "invalid-cert-hash"
          /* AuthErrorCode.INVALID_CERT_HASH */
        ]: "The SHA-1 certificate hash provided is invalid.",
        [
          "invalid-credential"
          /* AuthErrorCode.INVALID_CREDENTIAL */
        ]: "The supplied auth credential is incorrect, malformed or has expired.",
        [
          "invalid-message-payload"
          /* AuthErrorCode.INVALID_MESSAGE_PAYLOAD */
        ]: "The email template corresponding to this action contains invalid characters in its message. Please fix by going to the Auth email templates section in the Firebase Console.",
        [
          "invalid-multi-factor-session"
          /* AuthErrorCode.INVALID_MFA_SESSION */
        ]: "The request does not contain a valid proof of first factor successful sign-in.",
        [
          "invalid-oauth-provider"
          /* AuthErrorCode.INVALID_OAUTH_PROVIDER */
        ]: "EmailAuthProvider is not supported for this operation. This operation only supports OAuth providers.",
        [
          "invalid-oauth-client-id"
          /* AuthErrorCode.INVALID_OAUTH_CLIENT_ID */
        ]: "The OAuth client ID provided is either invalid or does not match the specified API key.",
        [
          "unauthorized-domain"
          /* AuthErrorCode.INVALID_ORIGIN */
        ]: "This domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.",
        [
          "invalid-action-code"
          /* AuthErrorCode.INVALID_OOB_CODE */
        ]: "The action code is invalid. This can happen if the code is malformed, expired, or has already been used.",
        [
          "wrong-password"
          /* AuthErrorCode.INVALID_PASSWORD */
        ]: "The password is invalid or the user does not have a password.",
        [
          "invalid-persistence-type"
          /* AuthErrorCode.INVALID_PERSISTENCE */
        ]: "The specified persistence type is invalid. It can only be local, session or none.",
        [
          "invalid-phone-number"
          /* AuthErrorCode.INVALID_PHONE_NUMBER */
        ]: "The format of the phone number provided is incorrect. Please enter the phone number in a format that can be parsed into E.164 format. E.164 phone numbers are written in the format [+][country code][subscriber number including area code].",
        [
          "invalid-provider-id"
          /* AuthErrorCode.INVALID_PROVIDER_ID */
        ]: "The specified provider ID is invalid.",
        [
          "invalid-recipient-email"
          /* AuthErrorCode.INVALID_RECIPIENT_EMAIL */
        ]: "The email corresponding to this action failed to send as the provided recipient email address is invalid.",
        [
          "invalid-sender"
          /* AuthErrorCode.INVALID_SENDER */
        ]: "The email template corresponding to this action contains an invalid sender email or name. Please fix by going to the Auth email templates section in the Firebase Console.",
        [
          "invalid-verification-id"
          /* AuthErrorCode.INVALID_SESSION_INFO */
        ]: "The verification ID used to create the phone auth credential is invalid.",
        [
          "invalid-tenant-id"
          /* AuthErrorCode.INVALID_TENANT_ID */
        ]: "The Auth instance's tenant ID is invalid.",
        [
          "login-blocked"
          /* AuthErrorCode.LOGIN_BLOCKED */
        ]: "Login blocked by user-provided method: {$originalMessage}",
        [
          "missing-android-pkg-name"
          /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */
        ]: "An Android Package Name must be provided if the Android App is required to be installed.",
        [
          "auth-domain-config-required"
          /* AuthErrorCode.MISSING_AUTH_DOMAIN */
        ]: "Be sure to include authDomain when calling firebase.initializeApp(), by following the instructions in the Firebase console.",
        [
          "missing-app-credential"
          /* AuthErrorCode.MISSING_APP_CREDENTIAL */
        ]: "The phone verification request is missing an application verifier assertion. A reCAPTCHA response token needs to be provided.",
        [
          "missing-verification-code"
          /* AuthErrorCode.MISSING_CODE */
        ]: "The phone auth credential was created with an empty SMS verification code.",
        [
          "missing-continue-uri"
          /* AuthErrorCode.MISSING_CONTINUE_URI */
        ]: "A continue URL must be provided in the request.",
        [
          "missing-iframe-start"
          /* AuthErrorCode.MISSING_IFRAME_START */
        ]: "An internal AuthError has occurred.",
        [
          "missing-ios-bundle-id"
          /* AuthErrorCode.MISSING_IOS_BUNDLE_ID */
        ]: "An iOS Bundle ID must be provided if an App Store ID is provided.",
        [
          "missing-or-invalid-nonce"
          /* AuthErrorCode.MISSING_OR_INVALID_NONCE */
        ]: "The request does not contain a valid nonce. This can occur if the SHA-256 hash of the provided raw nonce does not match the hashed nonce in the ID token payload.",
        [
          "missing-password"
          /* AuthErrorCode.MISSING_PASSWORD */
        ]: "A non-empty password must be provided",
        [
          "missing-multi-factor-info"
          /* AuthErrorCode.MISSING_MFA_INFO */
        ]: "No second factor identifier is provided.",
        [
          "missing-multi-factor-session"
          /* AuthErrorCode.MISSING_MFA_SESSION */
        ]: "The request is missing proof of first factor successful sign-in.",
        [
          "missing-phone-number"
          /* AuthErrorCode.MISSING_PHONE_NUMBER */
        ]: "To send verification codes, provide a phone number for the recipient.",
        [
          "missing-verification-id"
          /* AuthErrorCode.MISSING_SESSION_INFO */
        ]: "The phone auth credential was created with an empty verification ID.",
        [
          "app-deleted"
          /* AuthErrorCode.MODULE_DESTROYED */
        ]: "This instance of FirebaseApp has been deleted.",
        [
          "multi-factor-info-not-found"
          /* AuthErrorCode.MFA_INFO_NOT_FOUND */
        ]: "The user does not have a second factor matching the identifier provided.",
        [
          "multi-factor-auth-required"
          /* AuthErrorCode.MFA_REQUIRED */
        ]: "Proof of ownership of a second factor is required to complete sign-in.",
        [
          "account-exists-with-different-credential"
          /* AuthErrorCode.NEED_CONFIRMATION */
        ]: "An account already exists with the same email address but different sign-in credentials. Sign in using a provider associated with this email address.",
        [
          "network-request-failed"
          /* AuthErrorCode.NETWORK_REQUEST_FAILED */
        ]: "A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.",
        [
          "no-auth-event"
          /* AuthErrorCode.NO_AUTH_EVENT */
        ]: "An internal AuthError has occurred.",
        [
          "no-such-provider"
          /* AuthErrorCode.NO_SUCH_PROVIDER */
        ]: "User was not linked to an account with the given provider.",
        [
          "null-user"
          /* AuthErrorCode.NULL_USER */
        ]: "A null user object was provided as the argument for an operation which requires a non-null user object.",
        [
          "operation-not-allowed"
          /* AuthErrorCode.OPERATION_NOT_ALLOWED */
        ]: "The given sign-in provider is disabled for this Firebase project. Enable it in the Firebase console, under the sign-in method tab of the Auth section.",
        [
          "operation-not-supported-in-this-environment"
          /* AuthErrorCode.OPERATION_NOT_SUPPORTED */
        ]: 'This operation is not supported in the environment this application is running on. "location.protocol" must be http, https or chrome-extension and web storage must be enabled.',
        [
          "popup-blocked"
          /* AuthErrorCode.POPUP_BLOCKED */
        ]: "Unable to establish a connection with the popup. It may have been blocked by the browser.",
        [
          "popup-closed-by-user"
          /* AuthErrorCode.POPUP_CLOSED_BY_USER */
        ]: "The popup has been closed by the user before finalizing the operation.",
        [
          "provider-already-linked"
          /* AuthErrorCode.PROVIDER_ALREADY_LINKED */
        ]: "User can only be linked to one identity for the given provider.",
        [
          "quota-exceeded"
          /* AuthErrorCode.QUOTA_EXCEEDED */
        ]: "The project's quota for this operation has been exceeded.",
        [
          "redirect-cancelled-by-user"
          /* AuthErrorCode.REDIRECT_CANCELLED_BY_USER */
        ]: "The redirect operation has been cancelled by the user before finalizing.",
        [
          "redirect-operation-pending"
          /* AuthErrorCode.REDIRECT_OPERATION_PENDING */
        ]: "A redirect sign-in operation is already pending.",
        [
          "rejected-credential"
          /* AuthErrorCode.REJECTED_CREDENTIAL */
        ]: "The request contains malformed or mismatching credentials.",
        [
          "second-factor-already-in-use"
          /* AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED */
        ]: "The second factor is already enrolled on this account.",
        [
          "maximum-second-factor-count-exceeded"
          /* AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED */
        ]: "The maximum allowed number of second factors on a user has been exceeded.",
        [
          "tenant-id-mismatch"
          /* AuthErrorCode.TENANT_ID_MISMATCH */
        ]: "The provided tenant ID does not match the Auth instance's tenant ID",
        [
          "timeout"
          /* AuthErrorCode.TIMEOUT */
        ]: "The operation has timed out.",
        [
          "user-token-expired"
          /* AuthErrorCode.TOKEN_EXPIRED */
        ]: "The user's credential is no longer valid. The user must sign in again.",
        [
          "too-many-requests"
          /* AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER */
        ]: "We have blocked all requests from this device due to unusual activity. Try again later.",
        [
          "unauthorized-continue-uri"
          /* AuthErrorCode.UNAUTHORIZED_DOMAIN */
        ]: "The domain of the continue URL is not whitelisted.  Please whitelist the domain in the Firebase console.",
        [
          "unsupported-first-factor"
          /* AuthErrorCode.UNSUPPORTED_FIRST_FACTOR */
        ]: "Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.",
        [
          "unsupported-persistence-type"
          /* AuthErrorCode.UNSUPPORTED_PERSISTENCE */
        ]: "The current environment does not support the specified persistence type.",
        [
          "unsupported-tenant-operation"
          /* AuthErrorCode.UNSUPPORTED_TENANT_OPERATION */
        ]: "This operation is not supported in a multi-tenant context.",
        [
          "unverified-email"
          /* AuthErrorCode.UNVERIFIED_EMAIL */
        ]: "The operation requires a verified email.",
        [
          "user-cancelled"
          /* AuthErrorCode.USER_CANCELLED */
        ]: "The user did not grant your application the permissions it requested.",
        [
          "user-not-found"
          /* AuthErrorCode.USER_DELETED */
        ]: "There is no user record corresponding to this identifier. The user may have been deleted.",
        [
          "user-disabled"
          /* AuthErrorCode.USER_DISABLED */
        ]: "The user account has been disabled by an administrator.",
        [
          "user-mismatch"
          /* AuthErrorCode.USER_MISMATCH */
        ]: "The supplied credentials do not correspond to the previously signed in user.",
        [
          "user-signed-out"
          /* AuthErrorCode.USER_SIGNED_OUT */
        ]: "",
        [
          "weak-password"
          /* AuthErrorCode.WEAK_PASSWORD */
        ]: "The password must be 6 characters long or more.",
        [
          "web-storage-unsupported"
          /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */
        ]: "This browser is not supported or 3rd party cookies and data may be disabled.",
        [
          "already-initialized"
          /* AuthErrorCode.ALREADY_INITIALIZED */
        ]: "initializeAuth() has already been called with different options. To avoid this error, call initializeAuth() with the same options as when it was originally called, or call getAuth() to return the already initialized instance.",
        [
          "missing-recaptcha-token"
          /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */
        ]: "The reCAPTCHA token is missing when sending request to the backend.",
        [
          "invalid-recaptcha-token"
          /* AuthErrorCode.INVALID_RECAPTCHA_TOKEN */
        ]: "The reCAPTCHA token is invalid when sending request to the backend.",
        [
          "invalid-recaptcha-action"
          /* AuthErrorCode.INVALID_RECAPTCHA_ACTION */
        ]: "The reCAPTCHA action is invalid when sending request to the backend.",
        [
          "recaptcha-not-enabled"
          /* AuthErrorCode.RECAPTCHA_NOT_ENABLED */
        ]: "reCAPTCHA Enterprise integration is not enabled for this project.",
        [
          "missing-client-type"
          /* AuthErrorCode.MISSING_CLIENT_TYPE */
        ]: "The reCAPTCHA client type is missing when sending request to the backend.",
        [
          "missing-recaptcha-version"
          /* AuthErrorCode.MISSING_RECAPTCHA_VERSION */
        ]: "The reCAPTCHA version is missing when sending request to the backend.",
        [
          "invalid-req-type"
          /* AuthErrorCode.INVALID_REQ_TYPE */
        ]: "Invalid request parameters.",
        [
          "invalid-recaptcha-version"
          /* AuthErrorCode.INVALID_RECAPTCHA_VERSION */
        ]: "The reCAPTCHA version is invalid when sending request to the backend.",
        [
          "unsupported-password-policy-schema-version"
          /* AuthErrorCode.UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION */
        ]: "The password policy received from the backend uses a schema version that is not supported by this version of the Firebase SDK.",
        [
          "password-does-not-meet-requirements"
          /* AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS */
        ]: "The password does not meet the requirements.",
        [
          "invalid-hosting-link-domain"
          /* AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN */
        ]: "The provided Hosting link domain is not configured in Firebase Hosting or is not owned by the current project. This cannot be a default Hosting domain (`web.app` or `firebaseapp.com`)."
      };
    }
    function _prodErrorMap2() {
      return {
        [
          "dependent-sdk-initialized-before-auth"
          /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
        ]: "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK."
      };
    }
    var debugErrorMap2 = _debugErrorMap2;
    var prodErrorMap2 = _prodErrorMap2;
    var _DEFAULT_AUTH_ERROR_FACTORY2 = new util.ErrorFactory("auth", "Firebase", _prodErrorMap2());
    var AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY2 = {
      ADMIN_ONLY_OPERATION: "auth/admin-restricted-operation",
      ARGUMENT_ERROR: "auth/argument-error",
      APP_NOT_AUTHORIZED: "auth/app-not-authorized",
      APP_NOT_INSTALLED: "auth/app-not-installed",
      CAPTCHA_CHECK_FAILED: "auth/captcha-check-failed",
      CODE_EXPIRED: "auth/code-expired",
      CORDOVA_NOT_READY: "auth/cordova-not-ready",
      CORS_UNSUPPORTED: "auth/cors-unsupported",
      CREDENTIAL_ALREADY_IN_USE: "auth/credential-already-in-use",
      CREDENTIAL_MISMATCH: "auth/custom-token-mismatch",
      CREDENTIAL_TOO_OLD_LOGIN_AGAIN: "auth/requires-recent-login",
      DEPENDENT_SDK_INIT_BEFORE_AUTH: "auth/dependent-sdk-initialized-before-auth",
      DYNAMIC_LINK_NOT_ACTIVATED: "auth/dynamic-link-not-activated",
      EMAIL_CHANGE_NEEDS_VERIFICATION: "auth/email-change-needs-verification",
      EMAIL_EXISTS: "auth/email-already-in-use",
      EMULATOR_CONFIG_FAILED: "auth/emulator-config-failed",
      EXPIRED_OOB_CODE: "auth/expired-action-code",
      EXPIRED_POPUP_REQUEST: "auth/cancelled-popup-request",
      INTERNAL_ERROR: "auth/internal-error",
      INVALID_API_KEY: "auth/invalid-api-key",
      INVALID_APP_CREDENTIAL: "auth/invalid-app-credential",
      INVALID_APP_ID: "auth/invalid-app-id",
      INVALID_AUTH: "auth/invalid-user-token",
      INVALID_AUTH_EVENT: "auth/invalid-auth-event",
      INVALID_CERT_HASH: "auth/invalid-cert-hash",
      INVALID_CODE: "auth/invalid-verification-code",
      INVALID_CONTINUE_URI: "auth/invalid-continue-uri",
      INVALID_CORDOVA_CONFIGURATION: "auth/invalid-cordova-configuration",
      INVALID_CUSTOM_TOKEN: "auth/invalid-custom-token",
      INVALID_DYNAMIC_LINK_DOMAIN: "auth/invalid-dynamic-link-domain",
      INVALID_EMAIL: "auth/invalid-email",
      INVALID_EMULATOR_SCHEME: "auth/invalid-emulator-scheme",
      INVALID_IDP_RESPONSE: "auth/invalid-credential",
      INVALID_LOGIN_CREDENTIALS: "auth/invalid-credential",
      INVALID_MESSAGE_PAYLOAD: "auth/invalid-message-payload",
      INVALID_MFA_SESSION: "auth/invalid-multi-factor-session",
      INVALID_OAUTH_CLIENT_ID: "auth/invalid-oauth-client-id",
      INVALID_OAUTH_PROVIDER: "auth/invalid-oauth-provider",
      INVALID_OOB_CODE: "auth/invalid-action-code",
      INVALID_ORIGIN: "auth/unauthorized-domain",
      INVALID_PASSWORD: "auth/wrong-password",
      INVALID_PERSISTENCE: "auth/invalid-persistence-type",
      INVALID_PHONE_NUMBER: "auth/invalid-phone-number",
      INVALID_PROVIDER_ID: "auth/invalid-provider-id",
      INVALID_RECIPIENT_EMAIL: "auth/invalid-recipient-email",
      INVALID_SENDER: "auth/invalid-sender",
      INVALID_SESSION_INFO: "auth/invalid-verification-id",
      INVALID_TENANT_ID: "auth/invalid-tenant-id",
      MFA_INFO_NOT_FOUND: "auth/multi-factor-info-not-found",
      MFA_REQUIRED: "auth/multi-factor-auth-required",
      MISSING_ANDROID_PACKAGE_NAME: "auth/missing-android-pkg-name",
      MISSING_APP_CREDENTIAL: "auth/missing-app-credential",
      MISSING_AUTH_DOMAIN: "auth/auth-domain-config-required",
      MISSING_CODE: "auth/missing-verification-code",
      MISSING_CONTINUE_URI: "auth/missing-continue-uri",
      MISSING_IFRAME_START: "auth/missing-iframe-start",
      MISSING_IOS_BUNDLE_ID: "auth/missing-ios-bundle-id",
      MISSING_OR_INVALID_NONCE: "auth/missing-or-invalid-nonce",
      MISSING_MFA_INFO: "auth/missing-multi-factor-info",
      MISSING_MFA_SESSION: "auth/missing-multi-factor-session",
      MISSING_PHONE_NUMBER: "auth/missing-phone-number",
      MISSING_PASSWORD: "auth/missing-password",
      MISSING_SESSION_INFO: "auth/missing-verification-id",
      MODULE_DESTROYED: "auth/app-deleted",
      NEED_CONFIRMATION: "auth/account-exists-with-different-credential",
      NETWORK_REQUEST_FAILED: "auth/network-request-failed",
      NULL_USER: "auth/null-user",
      NO_AUTH_EVENT: "auth/no-auth-event",
      NO_SUCH_PROVIDER: "auth/no-such-provider",
      OPERATION_NOT_ALLOWED: "auth/operation-not-allowed",
      OPERATION_NOT_SUPPORTED: "auth/operation-not-supported-in-this-environment",
      POPUP_BLOCKED: "auth/popup-blocked",
      POPUP_CLOSED_BY_USER: "auth/popup-closed-by-user",
      PROVIDER_ALREADY_LINKED: "auth/provider-already-linked",
      QUOTA_EXCEEDED: "auth/quota-exceeded",
      REDIRECT_CANCELLED_BY_USER: "auth/redirect-cancelled-by-user",
      REDIRECT_OPERATION_PENDING: "auth/redirect-operation-pending",
      REJECTED_CREDENTIAL: "auth/rejected-credential",
      SECOND_FACTOR_ALREADY_ENROLLED: "auth/second-factor-already-in-use",
      SECOND_FACTOR_LIMIT_EXCEEDED: "auth/maximum-second-factor-count-exceeded",
      TENANT_ID_MISMATCH: "auth/tenant-id-mismatch",
      TIMEOUT: "auth/timeout",
      TOKEN_EXPIRED: "auth/user-token-expired",
      TOO_MANY_ATTEMPTS_TRY_LATER: "auth/too-many-requests",
      UNAUTHORIZED_DOMAIN: "auth/unauthorized-continue-uri",
      UNSUPPORTED_FIRST_FACTOR: "auth/unsupported-first-factor",
      UNSUPPORTED_PERSISTENCE: "auth/unsupported-persistence-type",
      UNSUPPORTED_TENANT_OPERATION: "auth/unsupported-tenant-operation",
      UNVERIFIED_EMAIL: "auth/unverified-email",
      USER_CANCELLED: "auth/user-cancelled",
      USER_DELETED: "auth/user-not-found",
      USER_DISABLED: "auth/user-disabled",
      USER_MISMATCH: "auth/user-mismatch",
      USER_SIGNED_OUT: "auth/user-signed-out",
      WEAK_PASSWORD: "auth/weak-password",
      WEB_STORAGE_UNSUPPORTED: "auth/web-storage-unsupported",
      ALREADY_INITIALIZED: "auth/already-initialized",
      RECAPTCHA_NOT_ENABLED: "auth/recaptcha-not-enabled",
      MISSING_RECAPTCHA_TOKEN: "auth/missing-recaptcha-token",
      INVALID_RECAPTCHA_TOKEN: "auth/invalid-recaptcha-token",
      INVALID_RECAPTCHA_ACTION: "auth/invalid-recaptcha-action",
      MISSING_CLIENT_TYPE: "auth/missing-client-type",
      MISSING_RECAPTCHA_VERSION: "auth/missing-recaptcha-version",
      INVALID_RECAPTCHA_VERSION: "auth/invalid-recaptcha-version",
      INVALID_REQ_TYPE: "auth/invalid-req-type",
      INVALID_HOSTING_LINK_DOMAIN: "auth/invalid-hosting-link-domain"
    };
    var logClient2 = new logger2.Logger("@firebase/auth");
    function _logWarn2(msg, ...args) {
      if (logClient2.logLevel <= logger2.LogLevel.WARN) {
        logClient2.warn(`Auth (${app2.SDK_VERSION}): ${msg}`, ...args);
      }
    }
    function _logError2(msg, ...args) {
      if (logClient2.logLevel <= logger2.LogLevel.ERROR) {
        logClient2.error(`Auth (${app2.SDK_VERSION}): ${msg}`, ...args);
      }
    }
    function _fail2(authOrCode, ...rest) {
      throw createErrorInternal2(authOrCode, ...rest);
    }
    function _createError2(authOrCode, ...rest) {
      return createErrorInternal2(authOrCode, ...rest);
    }
    function _errorWithCustomMessage2(auth2, code, message) {
      const errorMap = {
        ...prodErrorMap2(),
        [code]: message
      };
      const factory2 = new util.ErrorFactory("auth", "Firebase", errorMap);
      return factory2.create(code, {
        appName: auth2.name
      });
    }
    function _serverAppCurrentUserOperationNotSupportedError2(auth2) {
      return _errorWithCustomMessage2(auth2, "operation-not-supported-in-this-environment", "Operations that alter the current user are not supported in conjunction with FirebaseServerApp");
    }
    function createErrorInternal2(authOrCode, ...rest) {
      if (typeof authOrCode !== "string") {
        const code = rest[0];
        const fullParams = [...rest.slice(1)];
        if (fullParams[0]) {
          fullParams[0].appName = authOrCode.name;
        }
        return authOrCode._errorFactory.create(code, ...fullParams);
      }
      return _DEFAULT_AUTH_ERROR_FACTORY2.create(authOrCode, ...rest);
    }
    function _assert2(assertion, authOrCode, ...rest) {
      if (!assertion) {
        throw createErrorInternal2(authOrCode, ...rest);
      }
    }
    function debugFail2(failure) {
      const message = `INTERNAL ASSERTION FAILED: ` + failure;
      _logError2(message);
      throw new Error(message);
    }
    function debugAssert2(assertion, message) {
      if (!assertion) {
        debugFail2(message);
      }
    }
    function _getCurrentUrl2() {
      return typeof self !== "undefined" && self.location?.href || "";
    }
    function _isHttpOrHttps2() {
      return _getCurrentScheme2() === "http:" || _getCurrentScheme2() === "https:";
    }
    function _getCurrentScheme2() {
      return typeof self !== "undefined" && self.location?.protocol || null;
    }
    function _isOnline2() {
      if (typeof navigator !== "undefined" && navigator && "onLine" in navigator && typeof navigator.onLine === "boolean" && // Apply only for traditional web apps and Chrome extensions.
      // This is especially true for Cordova apps which have unreliable
      // navigator.onLine behavior unless cordova-plugin-network-information is
      // installed which overwrites the native navigator.onLine value and
      // defines navigator.connection.
      (_isHttpOrHttps2() || util.isBrowserExtension() || "connection" in navigator)) {
        return navigator.onLine;
      }
      return true;
    }
    function _getUserLanguage2() {
      if (typeof navigator === "undefined") {
        return null;
      }
      const navigatorLanguage = navigator;
      return (
        // Most reliable, but only supported in Chrome/Firefox.
        navigatorLanguage.languages && navigatorLanguage.languages[0] || // Supported in most browsers, but returns the language of the browser
        // UI, not the language set in browser settings.
        navigatorLanguage.language || // Couldn't determine language.
        null
      );
    }
    var Delay2 = class {
      constructor(shortDelay, longDelay) {
        this.shortDelay = shortDelay;
        this.longDelay = longDelay;
        debugAssert2(longDelay > shortDelay, "Short delay should be less than long delay!");
        this.isMobile = util.isMobileCordova() || util.isReactNative();
      }
      get() {
        if (!_isOnline2()) {
          return Math.min(5e3, this.shortDelay);
        }
        return this.isMobile ? this.longDelay : this.shortDelay;
      }
    };
    function _emulatorUrl2(config, path) {
      debugAssert2(config.emulator, "Emulator should always be set here");
      const { url } = config.emulator;
      if (!path) {
        return url;
      }
      return `${url}${path.startsWith("/") ? path.slice(1) : path}`;
    }
    var FetchProvider2 = class {
      static initialize(fetchImpl, headersImpl, responseImpl) {
        this.fetchImpl = fetchImpl;
        if (headersImpl) {
          this.headersImpl = headersImpl;
        }
        if (responseImpl) {
          this.responseImpl = responseImpl;
        }
      }
      static fetch() {
        if (this.fetchImpl) {
          return this.fetchImpl;
        }
        if (typeof self !== "undefined" && "fetch" in self) {
          return self.fetch;
        }
        if (typeof globalThis !== "undefined" && globalThis.fetch) {
          return globalThis.fetch;
        }
        if (typeof fetch !== "undefined") {
          return fetch;
        }
        debugFail2("Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
      }
      static headers() {
        if (this.headersImpl) {
          return this.headersImpl;
        }
        if (typeof self !== "undefined" && "Headers" in self) {
          return self.Headers;
        }
        if (typeof globalThis !== "undefined" && globalThis.Headers) {
          return globalThis.Headers;
        }
        if (typeof Headers !== "undefined") {
          return Headers;
        }
        debugFail2("Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
      }
      static response() {
        if (this.responseImpl) {
          return this.responseImpl;
        }
        if (typeof self !== "undefined" && "Response" in self) {
          return self.Response;
        }
        if (typeof globalThis !== "undefined" && globalThis.Response) {
          return globalThis.Response;
        }
        if (typeof Response !== "undefined") {
          return Response;
        }
        debugFail2("Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
      }
    };
    var SERVER_ERROR_MAP2 = {
      // Custom token errors.
      [
        "CREDENTIAL_MISMATCH"
        /* ServerError.CREDENTIAL_MISMATCH */
      ]: "custom-token-mismatch",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_CUSTOM_TOKEN"
        /* ServerError.MISSING_CUSTOM_TOKEN */
      ]: "internal-error",
      // Create Auth URI errors.
      [
        "INVALID_IDENTIFIER"
        /* ServerError.INVALID_IDENTIFIER */
      ]: "invalid-email",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_CONTINUE_URI"
        /* ServerError.MISSING_CONTINUE_URI */
      ]: "internal-error",
      // Sign in with email and password errors (some apply to sign up too).
      [
        "INVALID_PASSWORD"
        /* ServerError.INVALID_PASSWORD */
      ]: "wrong-password",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_PASSWORD"
        /* ServerError.MISSING_PASSWORD */
      ]: "missing-password",
      // Thrown if Email Enumeration Protection is enabled in the project and the email or password is
      // invalid.
      [
        "INVALID_LOGIN_CREDENTIALS"
        /* ServerError.INVALID_LOGIN_CREDENTIALS */
      ]: "invalid-credential",
      // Sign up with email and password errors.
      [
        "EMAIL_EXISTS"
        /* ServerError.EMAIL_EXISTS */
      ]: "email-already-in-use",
      [
        "PASSWORD_LOGIN_DISABLED"
        /* ServerError.PASSWORD_LOGIN_DISABLED */
      ]: "operation-not-allowed",
      // Verify assertion for sign in with credential errors:
      [
        "INVALID_IDP_RESPONSE"
        /* ServerError.INVALID_IDP_RESPONSE */
      ]: "invalid-credential",
      [
        "INVALID_PENDING_TOKEN"
        /* ServerError.INVALID_PENDING_TOKEN */
      ]: "invalid-credential",
      [
        "FEDERATED_USER_ID_ALREADY_LINKED"
        /* ServerError.FEDERATED_USER_ID_ALREADY_LINKED */
      ]: "credential-already-in-use",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_REQ_TYPE"
        /* ServerError.MISSING_REQ_TYPE */
      ]: "internal-error",
      // Send Password reset email errors:
      [
        "EMAIL_NOT_FOUND"
        /* ServerError.EMAIL_NOT_FOUND */
      ]: "user-not-found",
      [
        "RESET_PASSWORD_EXCEED_LIMIT"
        /* ServerError.RESET_PASSWORD_EXCEED_LIMIT */
      ]: "too-many-requests",
      [
        "EXPIRED_OOB_CODE"
        /* ServerError.EXPIRED_OOB_CODE */
      ]: "expired-action-code",
      [
        "INVALID_OOB_CODE"
        /* ServerError.INVALID_OOB_CODE */
      ]: "invalid-action-code",
      // This can only happen if the SDK sends a bad request.
      [
        "MISSING_OOB_CODE"
        /* ServerError.MISSING_OOB_CODE */
      ]: "internal-error",
      // Operations that require ID token in request:
      [
        "CREDENTIAL_TOO_OLD_LOGIN_AGAIN"
        /* ServerError.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */
      ]: "requires-recent-login",
      [
        "INVALID_ID_TOKEN"
        /* ServerError.INVALID_ID_TOKEN */
      ]: "invalid-user-token",
      [
        "TOKEN_EXPIRED"
        /* ServerError.TOKEN_EXPIRED */
      ]: "user-token-expired",
      [
        "USER_NOT_FOUND"
        /* ServerError.USER_NOT_FOUND */
      ]: "user-token-expired",
      // Other errors.
      [
        "TOO_MANY_ATTEMPTS_TRY_LATER"
        /* ServerError.TOO_MANY_ATTEMPTS_TRY_LATER */
      ]: "too-many-requests",
      [
        "PASSWORD_DOES_NOT_MEET_REQUIREMENTS"
        /* ServerError.PASSWORD_DOES_NOT_MEET_REQUIREMENTS */
      ]: "password-does-not-meet-requirements",
      // Phone Auth related errors.
      [
        "INVALID_CODE"
        /* ServerError.INVALID_CODE */
      ]: "invalid-verification-code",
      [
        "INVALID_SESSION_INFO"
        /* ServerError.INVALID_SESSION_INFO */
      ]: "invalid-verification-id",
      [
        "INVALID_TEMPORARY_PROOF"
        /* ServerError.INVALID_TEMPORARY_PROOF */
      ]: "invalid-credential",
      [
        "MISSING_SESSION_INFO"
        /* ServerError.MISSING_SESSION_INFO */
      ]: "missing-verification-id",
      [
        "SESSION_EXPIRED"
        /* ServerError.SESSION_EXPIRED */
      ]: "code-expired",
      // Other action code errors when additional settings passed.
      // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.
      // This is OK as this error will be caught by client side validation.
      [
        "MISSING_ANDROID_PACKAGE_NAME"
        /* ServerError.MISSING_ANDROID_PACKAGE_NAME */
      ]: "missing-android-pkg-name",
      [
        "UNAUTHORIZED_DOMAIN"
        /* ServerError.UNAUTHORIZED_DOMAIN */
      ]: "unauthorized-continue-uri",
      // getProjectConfig errors when clientId is passed.
      [
        "INVALID_OAUTH_CLIENT_ID"
        /* ServerError.INVALID_OAUTH_CLIENT_ID */
      ]: "invalid-oauth-client-id",
      // User actions (sign-up or deletion) disabled errors.
      [
        "ADMIN_ONLY_OPERATION"
        /* ServerError.ADMIN_ONLY_OPERATION */
      ]: "admin-restricted-operation",
      // Multi factor related errors.
      [
        "INVALID_MFA_PENDING_CREDENTIAL"
        /* ServerError.INVALID_MFA_PENDING_CREDENTIAL */
      ]: "invalid-multi-factor-session",
      [
        "MFA_ENROLLMENT_NOT_FOUND"
        /* ServerError.MFA_ENROLLMENT_NOT_FOUND */
      ]: "multi-factor-info-not-found",
      [
        "MISSING_MFA_ENROLLMENT_ID"
        /* ServerError.MISSING_MFA_ENROLLMENT_ID */
      ]: "missing-multi-factor-info",
      [
        "MISSING_MFA_PENDING_CREDENTIAL"
        /* ServerError.MISSING_MFA_PENDING_CREDENTIAL */
      ]: "missing-multi-factor-session",
      [
        "SECOND_FACTOR_EXISTS"
        /* ServerError.SECOND_FACTOR_EXISTS */
      ]: "second-factor-already-in-use",
      [
        "SECOND_FACTOR_LIMIT_EXCEEDED"
        /* ServerError.SECOND_FACTOR_LIMIT_EXCEEDED */
      ]: "maximum-second-factor-count-exceeded",
      // Blocking functions related errors.
      [
        "BLOCKING_FUNCTION_ERROR_RESPONSE"
        /* ServerError.BLOCKING_FUNCTION_ERROR_RESPONSE */
      ]: "internal-error",
      // Recaptcha related errors.
      [
        "RECAPTCHA_NOT_ENABLED"
        /* ServerError.RECAPTCHA_NOT_ENABLED */
      ]: "recaptcha-not-enabled",
      [
        "MISSING_RECAPTCHA_TOKEN"
        /* ServerError.MISSING_RECAPTCHA_TOKEN */
      ]: "missing-recaptcha-token",
      [
        "INVALID_RECAPTCHA_TOKEN"
        /* ServerError.INVALID_RECAPTCHA_TOKEN */
      ]: "invalid-recaptcha-token",
      [
        "INVALID_RECAPTCHA_ACTION"
        /* ServerError.INVALID_RECAPTCHA_ACTION */
      ]: "invalid-recaptcha-action",
      [
        "MISSING_CLIENT_TYPE"
        /* ServerError.MISSING_CLIENT_TYPE */
      ]: "missing-client-type",
      [
        "MISSING_RECAPTCHA_VERSION"
        /* ServerError.MISSING_RECAPTCHA_VERSION */
      ]: "missing-recaptcha-version",
      [
        "INVALID_RECAPTCHA_VERSION"
        /* ServerError.INVALID_RECAPTCHA_VERSION */
      ]: "invalid-recaptcha-version",
      [
        "INVALID_REQ_TYPE"
        /* ServerError.INVALID_REQ_TYPE */
      ]: "invalid-req-type"
      /* AuthErrorCode.INVALID_REQ_TYPE */
    };
    var CookieAuthProxiedEndpoints2 = [
      "/v1/accounts:signInWithCustomToken",
      "/v1/accounts:signInWithEmailLink",
      "/v1/accounts:signInWithIdp",
      "/v1/accounts:signInWithPassword",
      "/v1/accounts:signInWithPhoneNumber",
      "/v1/token"
      /* Endpoint.TOKEN */
    ];
    var DEFAULT_API_TIMEOUT_MS2 = new Delay2(3e4, 6e4);
    function _addTidIfNecessary2(auth2, request) {
      if (auth2.tenantId && !request.tenantId) {
        return {
          ...request,
          tenantId: auth2.tenantId
        };
      }
      return request;
    }
    async function _performApiRequest2(auth2, method, path, request, customErrorMap = {}) {
      return _performFetchWithErrorHandling2(auth2, customErrorMap, async () => {
        let body = {};
        let params = {};
        if (request) {
          if (method === "GET") {
            params = request;
          } else {
            body = {
              body: JSON.stringify(request)
            };
          }
        }
        const query = util.querystring({
          key: auth2.config.apiKey,
          ...params
        }).slice(1);
        const headers = await auth2._getAdditionalHeaders();
        headers[
          "Content-Type"
          /* HttpHeader.CONTENT_TYPE */
        ] = "application/json";
        if (auth2.languageCode) {
          headers[
            "X-Firebase-Locale"
            /* HttpHeader.X_FIREBASE_LOCALE */
          ] = auth2.languageCode;
        }
        const fetchArgs = {
          method,
          headers,
          ...body
        };
        if (!util.isCloudflareWorker()) {
          fetchArgs.referrerPolicy = "no-referrer";
        }
        if (auth2.emulatorConfig && util.isCloudWorkstation(auth2.emulatorConfig.host)) {
          fetchArgs.credentials = "include";
        }
        return FetchProvider2.fetch()(await _getFinalTarget2(auth2, auth2.config.apiHost, path, query), fetchArgs);
      });
    }
    async function _performFetchWithErrorHandling2(auth2, customErrorMap, fetchFn) {
      auth2._canInitEmulator = false;
      const errorMap = { ...SERVER_ERROR_MAP2, ...customErrorMap };
      try {
        const networkTimeout = new NetworkTimeout2(auth2);
        const response = await Promise.race([
          fetchFn(),
          networkTimeout.promise
        ]);
        networkTimeout.clearNetworkTimeout();
        const json = await response.json();
        if ("needConfirmation" in json) {
          throw _makeTaggedError2(auth2, "account-exists-with-different-credential", json);
        }
        if (response.ok && !("errorMessage" in json)) {
          return json;
        } else {
          const errorMessage = response.ok ? json.errorMessage : json.error.message;
          const [serverErrorCode, serverErrorMessage] = errorMessage.split(" : ");
          if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED") {
            throw _makeTaggedError2(auth2, "credential-already-in-use", json);
          } else if (serverErrorCode === "EMAIL_EXISTS") {
            throw _makeTaggedError2(auth2, "email-already-in-use", json);
          } else if (serverErrorCode === "USER_DISABLED") {
            throw _makeTaggedError2(auth2, "user-disabled", json);
          }
          const authError = errorMap[serverErrorCode] || serverErrorCode.toLowerCase().replace(/[_\s]+/g, "-");
          if (serverErrorMessage) {
            throw _errorWithCustomMessage2(auth2, authError, serverErrorMessage);
          } else {
            _fail2(auth2, authError);
          }
        }
      } catch (e) {
        if (e instanceof util.FirebaseError) {
          throw e;
        }
        _fail2(auth2, "network-request-failed", { "message": String(e) });
      }
    }
    async function _performSignInRequest2(auth2, method, path, request, customErrorMap = {}) {
      const serverResponse = await _performApiRequest2(auth2, method, path, request, customErrorMap);
      if ("mfaPendingCredential" in serverResponse) {
        _fail2(auth2, "multi-factor-auth-required", {
          _serverResponse: serverResponse
        });
      }
      return serverResponse;
    }
    async function _getFinalTarget2(auth2, host, path, query) {
      const base = `${host}${path}?${query}`;
      const authInternal = auth2;
      const finalTarget = authInternal.config.emulator ? _emulatorUrl2(auth2.config, base) : `${auth2.config.apiScheme}://${base}`;
      if (CookieAuthProxiedEndpoints2.includes(path)) {
        await authInternal._persistenceManagerAvailable;
        if (authInternal._getPersistenceType() === "COOKIE") {
          const cookiePersistence = authInternal._getPersistence();
          return cookiePersistence._getFinalTarget(finalTarget).toString();
        }
      }
      return finalTarget;
    }
    function _parseEnforcementState2(enforcementStateStr) {
      switch (enforcementStateStr) {
        case "ENFORCE":
          return "ENFORCE";
        case "AUDIT":
          return "AUDIT";
        case "OFF":
          return "OFF";
        default:
          return "ENFORCEMENT_STATE_UNSPECIFIED";
      }
    }
    var NetworkTimeout2 = class {
      clearNetworkTimeout() {
        clearTimeout(this.timer);
      }
      constructor(auth2) {
        this.auth = auth2;
        this.timer = null;
        this.promise = new Promise((_, reject) => {
          this.timer = setTimeout(() => {
            return reject(_createError2(
              this.auth,
              "network-request-failed"
              /* AuthErrorCode.NETWORK_REQUEST_FAILED */
            ));
          }, DEFAULT_API_TIMEOUT_MS2.get());
        });
      }
    };
    function _makeTaggedError2(auth2, code, response) {
      const errorParams = {
        appName: auth2.name
      };
      if (response.email) {
        errorParams.email = response.email;
      }
      if (response.phoneNumber) {
        errorParams.phoneNumber = response.phoneNumber;
      }
      const error = _createError2(auth2, code, errorParams);
      error.customData._tokenResponse = response;
      return error;
    }
    function isEnterprise2(grecaptcha) {
      return grecaptcha !== void 0 && grecaptcha.enterprise !== void 0;
    }
    var RecaptchaConfig2 = class {
      constructor(response) {
        this.siteKey = "";
        this.recaptchaEnforcementState = [];
        if (response.recaptchaKey === void 0) {
          throw new Error("recaptchaKey undefined");
        }
        this.siteKey = response.recaptchaKey.split("/")[3];
        this.recaptchaEnforcementState = response.recaptchaEnforcementState;
      }
      /**
       * Returns the reCAPTCHA Enterprise enforcement state for the given provider.
       *
       * @param providerStr - The provider whose enforcement state is to be returned.
       * @returns The reCAPTCHA Enterprise enforcement state for the given provider.
       */
      getProviderEnforcementState(providerStr) {
        if (!this.recaptchaEnforcementState || this.recaptchaEnforcementState.length === 0) {
          return null;
        }
        for (const recaptchaEnforcementState of this.recaptchaEnforcementState) {
          if (recaptchaEnforcementState.provider && recaptchaEnforcementState.provider === providerStr) {
            return _parseEnforcementState2(recaptchaEnforcementState.enforcementState);
          }
        }
        return null;
      }
      /**
       * Returns true if the reCAPTCHA Enterprise enforcement state for the provider is set to ENFORCE or AUDIT.
       *
       * @param providerStr - The provider whose enablement state is to be returned.
       * @returns Whether or not reCAPTCHA Enterprise protection is enabled for the given provider.
       */
      isProviderEnabled(providerStr) {
        return this.getProviderEnforcementState(providerStr) === "ENFORCE" || this.getProviderEnforcementState(providerStr) === "AUDIT";
      }
      /**
       * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise
       * returns false.
       *
       * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.
       */
      isAnyProviderEnabled() {
        return this.isProviderEnabled(
          "EMAIL_PASSWORD_PROVIDER"
          /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
        ) || this.isProviderEnabled(
          "PHONE_PROVIDER"
          /* RecaptchaAuthProvider.PHONE_PROVIDER */
        );
      }
    };
    async function getRecaptchaConfig2(auth2, request) {
      return _performApiRequest2(auth2, "GET", "/v2/recaptchaConfig", _addTidIfNecessary2(auth2, request));
    }
    async function deleteAccount2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:delete", request);
    }
    async function deleteLinkedAccounts2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:update", request);
    }
    async function getAccountInfo2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:lookup", request);
    }
    function utcTimestampToDateString2(utcTimestamp) {
      if (!utcTimestamp) {
        return void 0;
      }
      try {
        const date = new Date(Number(utcTimestamp));
        if (!isNaN(date.getTime())) {
          return date.toUTCString();
        }
      } catch (e) {
      }
      return void 0;
    }
    function getIdToken2(user, forceRefresh = false) {
      return util.getModularInstance(user).getIdToken(forceRefresh);
    }
    async function getIdTokenResult2(user, forceRefresh = false) {
      const userInternal = util.getModularInstance(user);
      const token = await userInternal.getIdToken(forceRefresh);
      const claims = _parseToken2(token);
      _assert2(
        claims && claims.exp && claims.auth_time && claims.iat,
        userInternal.auth,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      const firebase = typeof claims.firebase === "object" ? claims.firebase : void 0;
      const signInProvider = firebase?.["sign_in_provider"];
      return {
        claims,
        token,
        authTime: utcTimestampToDateString2(secondsStringToMilliseconds2(claims.auth_time)),
        issuedAtTime: utcTimestampToDateString2(secondsStringToMilliseconds2(claims.iat)),
        expirationTime: utcTimestampToDateString2(secondsStringToMilliseconds2(claims.exp)),
        signInProvider: signInProvider || null,
        signInSecondFactor: firebase?.["sign_in_second_factor"] || null
      };
    }
    function secondsStringToMilliseconds2(seconds) {
      return Number(seconds) * 1e3;
    }
    function _parseToken2(token) {
      const [algorithm, payload, signature] = token.split(".");
      if (algorithm === void 0 || payload === void 0 || signature === void 0) {
        _logError2("JWT malformed, contained fewer than 3 sections");
        return null;
      }
      try {
        const decoded = util.base64Decode(payload);
        if (!decoded) {
          _logError2("Failed to decode base64 JWT payload");
          return null;
        }
        return JSON.parse(decoded);
      } catch (e) {
        _logError2("Caught error parsing JWT payload as JSON", e?.toString());
        return null;
      }
    }
    function _tokenExpiresIn2(token) {
      const parsedToken = _parseToken2(token);
      _assert2(
        parsedToken,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      _assert2(
        typeof parsedToken.exp !== "undefined",
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      _assert2(
        typeof parsedToken.iat !== "undefined",
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      return Number(parsedToken.exp) - Number(parsedToken.iat);
    }
    async function _logoutIfInvalidated2(user, promise, bypassAuthState = false) {
      if (bypassAuthState) {
        return promise;
      }
      try {
        return await promise;
      } catch (e) {
        if (e instanceof util.FirebaseError && isUserInvalidated2(e)) {
          if (user.auth.currentUser === user) {
            await user.auth.signOut();
          }
        }
        throw e;
      }
    }
    function isUserInvalidated2({ code }) {
      return code === `auth/${"user-disabled"}` || code === `auth/${"user-token-expired"}`;
    }
    var ProactiveRefresh2 = class {
      constructor(user) {
        this.user = user;
        this.isRunning = false;
        this.timerId = null;
        this.errorBackoff = 3e4;
      }
      _start() {
        if (this.isRunning) {
          return;
        }
        this.isRunning = true;
        this.schedule();
      }
      _stop() {
        if (!this.isRunning) {
          return;
        }
        this.isRunning = false;
        if (this.timerId !== null) {
          clearTimeout(this.timerId);
        }
      }
      getInterval(wasError) {
        if (wasError) {
          const interval = this.errorBackoff;
          this.errorBackoff = Math.min(
            this.errorBackoff * 2,
            96e4
            /* Duration.RETRY_BACKOFF_MAX */
          );
          return interval;
        } else {
          this.errorBackoff = 3e4;
          const expTime = this.user.stsTokenManager.expirationTime ?? 0;
          const interval = expTime - Date.now() - 3e5;
          return Math.max(0, interval);
        }
      }
      schedule(wasError = false) {
        if (!this.isRunning) {
          return;
        }
        const interval = this.getInterval(wasError);
        this.timerId = setTimeout(async () => {
          await this.iteration();
        }, interval);
      }
      async iteration() {
        try {
          await this.user.getIdToken(true);
        } catch (e) {
          if (e?.code === `auth/${"network-request-failed"}`) {
            this.schedule(
              /* wasError */
              true
            );
          }
          return;
        }
        this.schedule();
      }
    };
    var UserMetadata2 = class {
      constructor(createdAt, lastLoginAt) {
        this.createdAt = createdAt;
        this.lastLoginAt = lastLoginAt;
        this._initializeTime();
      }
      _initializeTime() {
        this.lastSignInTime = utcTimestampToDateString2(this.lastLoginAt);
        this.creationTime = utcTimestampToDateString2(this.createdAt);
      }
      _copy(metadata) {
        this.createdAt = metadata.createdAt;
        this.lastLoginAt = metadata.lastLoginAt;
        this._initializeTime();
      }
      toJSON() {
        return {
          createdAt: this.createdAt,
          lastLoginAt: this.lastLoginAt
        };
      }
    };
    async function _reloadWithoutSaving2(user) {
      const auth2 = user.auth;
      const idToken = await user.getIdToken();
      const response = await _logoutIfInvalidated2(user, getAccountInfo2(auth2, { idToken }));
      _assert2(
        response?.users.length,
        auth2,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      const coreAccount = response.users[0];
      user._notifyReloadListener(coreAccount);
      const newProviderData = coreAccount.providerUserInfo?.length ? extractProviderData2(coreAccount.providerUserInfo) : [];
      const providerData = mergeProviderData2(user.providerData, newProviderData);
      const oldIsAnonymous = user.isAnonymous;
      const newIsAnonymous = !(user.email && coreAccount.passwordHash) && !providerData?.length;
      const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;
      const updates = {
        uid: coreAccount.localId,
        displayName: coreAccount.displayName || null,
        photoURL: coreAccount.photoUrl || null,
        email: coreAccount.email || null,
        emailVerified: coreAccount.emailVerified || false,
        phoneNumber: coreAccount.phoneNumber || null,
        tenantId: coreAccount.tenantId || null,
        providerData,
        metadata: new UserMetadata2(coreAccount.createdAt, coreAccount.lastLoginAt),
        isAnonymous
      };
      Object.assign(user, updates);
    }
    async function reload2(user) {
      const userInternal = util.getModularInstance(user);
      await _reloadWithoutSaving2(userInternal);
      await userInternal.auth._persistUserIfCurrent(userInternal);
      userInternal.auth._notifyListenersIfCurrent(userInternal);
    }
    function mergeProviderData2(original, newData) {
      const deduped = original.filter((o) => !newData.some((n) => n.providerId === o.providerId));
      return [...deduped, ...newData];
    }
    function extractProviderData2(providers) {
      return providers.map(({ providerId, ...provider }) => {
        return {
          providerId,
          uid: provider.rawId || "",
          displayName: provider.displayName || null,
          email: provider.email || null,
          phoneNumber: provider.phoneNumber || null,
          photoURL: provider.photoUrl || null
        };
      });
    }
    async function requestStsToken2(auth2, refreshToken) {
      const response = await _performFetchWithErrorHandling2(auth2, {}, async () => {
        const body = util.querystring({
          "grant_type": "refresh_token",
          "refresh_token": refreshToken
        }).slice(1);
        const { tokenApiHost, apiKey } = auth2.config;
        const url = await _getFinalTarget2(auth2, tokenApiHost, "/v1/token", `key=${apiKey}`);
        const headers = await auth2._getAdditionalHeaders();
        headers[
          "Content-Type"
          /* HttpHeader.CONTENT_TYPE */
        ] = "application/x-www-form-urlencoded";
        const options = {
          method: "POST",
          headers,
          body
        };
        if (auth2.emulatorConfig && util.isCloudWorkstation(auth2.emulatorConfig.host)) {
          options.credentials = "include";
        }
        return FetchProvider2.fetch()(url, options);
      });
      return {
        accessToken: response.access_token,
        expiresIn: response.expires_in,
        refreshToken: response.refresh_token
      };
    }
    async function revokeToken2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v2/accounts:revokeToken", _addTidIfNecessary2(auth2, request));
    }
    var StsTokenManager2 = class _StsTokenManager {
      constructor() {
        this.refreshToken = null;
        this.accessToken = null;
        this.expirationTime = null;
      }
      get isExpired() {
        return !this.expirationTime || Date.now() > this.expirationTime - 3e4;
      }
      updateFromServerResponse(response) {
        _assert2(
          response.idToken,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        _assert2(
          typeof response.idToken !== "undefined",
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        _assert2(
          typeof response.refreshToken !== "undefined",
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const expiresIn = "expiresIn" in response && typeof response.expiresIn !== "undefined" ? Number(response.expiresIn) : _tokenExpiresIn2(response.idToken);
        this.updateTokensAndExpiration(response.idToken, response.refreshToken, expiresIn);
      }
      updateFromIdToken(idToken) {
        _assert2(
          idToken.length !== 0,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const expiresIn = _tokenExpiresIn2(idToken);
        this.updateTokensAndExpiration(idToken, null, expiresIn);
      }
      async getToken(auth2, forceRefresh = false) {
        if (!forceRefresh && this.accessToken && !this.isExpired) {
          return this.accessToken;
        }
        _assert2(
          this.refreshToken,
          auth2,
          "user-token-expired"
          /* AuthErrorCode.TOKEN_EXPIRED */
        );
        if (this.refreshToken) {
          await this.refresh(auth2, this.refreshToken);
          return this.accessToken;
        }
        return null;
      }
      clearRefreshToken() {
        this.refreshToken = null;
      }
      async refresh(auth2, oldToken) {
        const { accessToken, refreshToken, expiresIn } = await requestStsToken2(auth2, oldToken);
        this.updateTokensAndExpiration(accessToken, refreshToken, Number(expiresIn));
      }
      updateTokensAndExpiration(accessToken, refreshToken, expiresInSec) {
        this.refreshToken = refreshToken || null;
        this.accessToken = accessToken || null;
        this.expirationTime = Date.now() + expiresInSec * 1e3;
      }
      static fromJSON(appName, object) {
        const { refreshToken, accessToken, expirationTime } = object;
        const manager = new _StsTokenManager();
        if (refreshToken) {
          _assert2(typeof refreshToken === "string", "internal-error", {
            appName
          });
          manager.refreshToken = refreshToken;
        }
        if (accessToken) {
          _assert2(typeof accessToken === "string", "internal-error", {
            appName
          });
          manager.accessToken = accessToken;
        }
        if (expirationTime) {
          _assert2(typeof expirationTime === "number", "internal-error", {
            appName
          });
          manager.expirationTime = expirationTime;
        }
        return manager;
      }
      toJSON() {
        return {
          refreshToken: this.refreshToken,
          accessToken: this.accessToken,
          expirationTime: this.expirationTime
        };
      }
      _assign(stsTokenManager) {
        this.accessToken = stsTokenManager.accessToken;
        this.refreshToken = stsTokenManager.refreshToken;
        this.expirationTime = stsTokenManager.expirationTime;
      }
      _clone() {
        return Object.assign(new _StsTokenManager(), this.toJSON());
      }
      _performRefresh() {
        return debugFail2("not implemented");
      }
    };
    function assertStringOrUndefined2(assertion, appName) {
      _assert2(typeof assertion === "string" || typeof assertion === "undefined", "internal-error", { appName });
    }
    var UserImpl2 = class _UserImpl {
      constructor({ uid, auth: auth2, stsTokenManager, ...opt }) {
        this.providerId = "firebase";
        this.proactiveRefresh = new ProactiveRefresh2(this);
        this.reloadUserInfo = null;
        this.reloadListener = null;
        this.uid = uid;
        this.auth = auth2;
        this.stsTokenManager = stsTokenManager;
        this.accessToken = stsTokenManager.accessToken;
        this.displayName = opt.displayName || null;
        this.email = opt.email || null;
        this.emailVerified = opt.emailVerified || false;
        this.phoneNumber = opt.phoneNumber || null;
        this.photoURL = opt.photoURL || null;
        this.isAnonymous = opt.isAnonymous || false;
        this.tenantId = opt.tenantId || null;
        this.providerData = opt.providerData ? [...opt.providerData] : [];
        this.metadata = new UserMetadata2(opt.createdAt || void 0, opt.lastLoginAt || void 0);
      }
      async getIdToken(forceRefresh) {
        const accessToken = await _logoutIfInvalidated2(this, this.stsTokenManager.getToken(this.auth, forceRefresh));
        _assert2(
          accessToken,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        if (this.accessToken !== accessToken) {
          this.accessToken = accessToken;
          await this.auth._persistUserIfCurrent(this);
          this.auth._notifyListenersIfCurrent(this);
        }
        return accessToken;
      }
      getIdTokenResult(forceRefresh) {
        return getIdTokenResult2(this, forceRefresh);
      }
      reload() {
        return reload2(this);
      }
      _assign(user) {
        if (this === user) {
          return;
        }
        _assert2(
          this.uid === user.uid,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        this.displayName = user.displayName;
        this.photoURL = user.photoURL;
        this.email = user.email;
        this.emailVerified = user.emailVerified;
        this.phoneNumber = user.phoneNumber;
        this.isAnonymous = user.isAnonymous;
        this.tenantId = user.tenantId;
        this.providerData = user.providerData.map((userInfo) => ({ ...userInfo }));
        this.metadata._copy(user.metadata);
        this.stsTokenManager._assign(user.stsTokenManager);
      }
      _clone(auth2) {
        const newUser = new _UserImpl({
          ...this,
          auth: auth2,
          stsTokenManager: this.stsTokenManager._clone()
        });
        newUser.metadata._copy(this.metadata);
        return newUser;
      }
      _onReload(callback) {
        _assert2(
          !this.reloadListener,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        this.reloadListener = callback;
        if (this.reloadUserInfo) {
          this._notifyReloadListener(this.reloadUserInfo);
          this.reloadUserInfo = null;
        }
      }
      _notifyReloadListener(userInfo) {
        if (this.reloadListener) {
          this.reloadListener(userInfo);
        } else {
          this.reloadUserInfo = userInfo;
        }
      }
      _startProactiveRefresh() {
        this.proactiveRefresh._start();
      }
      _stopProactiveRefresh() {
        this.proactiveRefresh._stop();
      }
      async _updateTokensIfNecessary(response, reload3 = false) {
        let tokensRefreshed = false;
        if (response.idToken && response.idToken !== this.stsTokenManager.accessToken) {
          this.stsTokenManager.updateFromServerResponse(response);
          tokensRefreshed = true;
        }
        if (reload3) {
          await _reloadWithoutSaving2(this);
        }
        await this.auth._persistUserIfCurrent(this);
        if (tokensRefreshed) {
          this.auth._notifyListenersIfCurrent(this);
        }
      }
      async delete() {
        if (app2._isFirebaseServerApp(this.auth.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(this.auth));
        }
        const idToken = await this.getIdToken();
        await _logoutIfInvalidated2(this, deleteAccount2(this.auth, { idToken }));
        this.stsTokenManager.clearRefreshToken();
        return this.auth.signOut();
      }
      toJSON() {
        return {
          uid: this.uid,
          email: this.email || void 0,
          emailVerified: this.emailVerified,
          displayName: this.displayName || void 0,
          isAnonymous: this.isAnonymous,
          photoURL: this.photoURL || void 0,
          phoneNumber: this.phoneNumber || void 0,
          tenantId: this.tenantId || void 0,
          providerData: this.providerData.map((userInfo) => ({ ...userInfo })),
          stsTokenManager: this.stsTokenManager.toJSON(),
          // Redirect event ID must be maintained in case there is a pending
          // redirect event.
          _redirectEventId: this._redirectEventId,
          ...this.metadata.toJSON(),
          // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):
          apiKey: this.auth.config.apiKey,
          appName: this.auth.name
          // Missing authDomain will be tolerated by the legacy SDK.
          // stsTokenManager.apiKey isn't actually required (despite the legacy SDK persisting it).
        };
      }
      get refreshToken() {
        return this.stsTokenManager.refreshToken || "";
      }
      static _fromJSON(auth2, object) {
        const displayName = object.displayName ?? void 0;
        const email = object.email ?? void 0;
        const phoneNumber = object.phoneNumber ?? void 0;
        const photoURL = object.photoURL ?? void 0;
        const tenantId = object.tenantId ?? void 0;
        const _redirectEventId = object._redirectEventId ?? void 0;
        const createdAt = object.createdAt ?? void 0;
        const lastLoginAt = object.lastLoginAt ?? void 0;
        const { uid, emailVerified, isAnonymous, providerData, stsTokenManager: plainObjectTokenManager } = object;
        _assert2(
          uid && plainObjectTokenManager,
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const stsTokenManager = StsTokenManager2.fromJSON(this.name, plainObjectTokenManager);
        _assert2(
          typeof uid === "string",
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        assertStringOrUndefined2(displayName, auth2.name);
        assertStringOrUndefined2(email, auth2.name);
        _assert2(
          typeof emailVerified === "boolean",
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        _assert2(
          typeof isAnonymous === "boolean",
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        assertStringOrUndefined2(phoneNumber, auth2.name);
        assertStringOrUndefined2(photoURL, auth2.name);
        assertStringOrUndefined2(tenantId, auth2.name);
        assertStringOrUndefined2(_redirectEventId, auth2.name);
        assertStringOrUndefined2(createdAt, auth2.name);
        assertStringOrUndefined2(lastLoginAt, auth2.name);
        const user = new _UserImpl({
          uid,
          auth: auth2,
          email,
          emailVerified,
          displayName,
          isAnonymous,
          photoURL,
          phoneNumber,
          tenantId,
          stsTokenManager,
          createdAt,
          lastLoginAt
        });
        if (providerData && Array.isArray(providerData)) {
          user.providerData = providerData.map((userInfo) => ({ ...userInfo }));
        }
        if (_redirectEventId) {
          user._redirectEventId = _redirectEventId;
        }
        return user;
      }
      /**
       * Initialize a User from an idToken server response
       * @param auth
       * @param idTokenResponse
       */
      static async _fromIdTokenResponse(auth2, idTokenResponse, isAnonymous = false) {
        const stsTokenManager = new StsTokenManager2();
        stsTokenManager.updateFromServerResponse(idTokenResponse);
        const user = new _UserImpl({
          uid: idTokenResponse.localId,
          auth: auth2,
          stsTokenManager,
          isAnonymous
        });
        await _reloadWithoutSaving2(user);
        return user;
      }
      /**
       * Initialize a User from an idToken server response
       * @param auth
       * @param idTokenResponse
       */
      static async _fromGetAccountInfoResponse(auth2, response, idToken) {
        const coreAccount = response.users[0];
        _assert2(
          coreAccount.localId !== void 0,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const providerData = coreAccount.providerUserInfo !== void 0 ? extractProviderData2(coreAccount.providerUserInfo) : [];
        const isAnonymous = !(coreAccount.email && coreAccount.passwordHash) && !providerData?.length;
        const stsTokenManager = new StsTokenManager2();
        stsTokenManager.updateFromIdToken(idToken);
        const user = new _UserImpl({
          uid: coreAccount.localId,
          auth: auth2,
          stsTokenManager,
          isAnonymous
        });
        const updates = {
          uid: coreAccount.localId,
          displayName: coreAccount.displayName || null,
          photoURL: coreAccount.photoUrl || null,
          email: coreAccount.email || null,
          emailVerified: coreAccount.emailVerified || false,
          phoneNumber: coreAccount.phoneNumber || null,
          tenantId: coreAccount.tenantId || null,
          providerData,
          metadata: new UserMetadata2(coreAccount.createdAt, coreAccount.lastLoginAt),
          isAnonymous: !(coreAccount.email && coreAccount.passwordHash) && !providerData?.length
        };
        Object.assign(user, updates);
        return user;
      }
    };
    var instanceCache2 = /* @__PURE__ */ new Map();
    function _getInstance2(cls) {
      debugAssert2(cls instanceof Function, "Expected a class definition");
      let instance = instanceCache2.get(cls);
      if (instance) {
        debugAssert2(instance instanceof cls, "Instance stored in cache mismatched with class");
        return instance;
      }
      instance = new cls();
      instanceCache2.set(cls, instance);
      return instance;
    }
    var InMemoryPersistence2 = class {
      constructor() {
        this.type = "NONE";
        this.storage = {};
      }
      async _isAvailable() {
        return true;
      }
      async _set(key, value) {
        this.storage[key] = value;
      }
      async _get(key) {
        const value = this.storage[key];
        return value === void 0 ? null : value;
      }
      async _remove(key) {
        delete this.storage[key];
      }
      _addListener(_key, _listener) {
        return;
      }
      _removeListener(_key, _listener) {
        return;
      }
    };
    InMemoryPersistence2.type = "NONE";
    var inMemoryPersistence2 = InMemoryPersistence2;
    function _persistenceKeyName2(key, apiKey, appName) {
      return `${"firebase"}:${key}:${apiKey}:${appName}`;
    }
    var PersistenceUserManager2 = class _PersistenceUserManager {
      constructor(persistence, auth2, userKey) {
        this.persistence = persistence;
        this.auth = auth2;
        this.userKey = userKey;
        const { config, name: name7 } = this.auth;
        this.fullUserKey = _persistenceKeyName2(this.userKey, config.apiKey, name7);
        this.fullPersistenceKey = _persistenceKeyName2("persistence", config.apiKey, name7);
        this.boundEventHandler = auth2._onStorageEvent.bind(auth2);
        this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
      }
      setCurrentUser(user) {
        return this.persistence._set(this.fullUserKey, user.toJSON());
      }
      async getCurrentUser() {
        const blob = await this.persistence._get(this.fullUserKey);
        if (!blob) {
          return null;
        }
        if (typeof blob === "string") {
          const response = await getAccountInfo2(this.auth, { idToken: blob }).catch(() => void 0);
          if (!response) {
            return null;
          }
          return UserImpl2._fromGetAccountInfoResponse(this.auth, response, blob);
        }
        return UserImpl2._fromJSON(this.auth, blob);
      }
      removeCurrentUser() {
        return this.persistence._remove(this.fullUserKey);
      }
      savePersistenceForRedirect() {
        return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
      }
      async setPersistence(newPersistence) {
        if (this.persistence === newPersistence) {
          return;
        }
        const currentUser = await this.getCurrentUser();
        await this.removeCurrentUser();
        this.persistence = newPersistence;
        if (currentUser) {
          return this.setCurrentUser(currentUser);
        }
      }
      delete() {
        this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
      }
      static async create(auth2, persistenceHierarchy, userKey = "authUser") {
        if (!persistenceHierarchy.length) {
          return new _PersistenceUserManager(_getInstance2(inMemoryPersistence2), auth2, userKey);
        }
        const availablePersistences = (await Promise.all(persistenceHierarchy.map(async (persistence) => {
          if (await persistence._isAvailable()) {
            return persistence;
          }
          return void 0;
        }))).filter((persistence) => persistence);
        let selectedPersistence = availablePersistences[0] || _getInstance2(inMemoryPersistence2);
        const key = _persistenceKeyName2(userKey, auth2.config.apiKey, auth2.name);
        let userToMigrate = null;
        for (const persistence of persistenceHierarchy) {
          try {
            const blob = await persistence._get(key);
            if (blob) {
              let user;
              if (typeof blob === "string") {
                const response = await getAccountInfo2(auth2, {
                  idToken: blob
                }).catch(() => void 0);
                if (!response) {
                  break;
                }
                user = await UserImpl2._fromGetAccountInfoResponse(auth2, response, blob);
              } else {
                user = UserImpl2._fromJSON(auth2, blob);
              }
              if (persistence !== selectedPersistence) {
                userToMigrate = user;
              }
              selectedPersistence = persistence;
              break;
            }
          } catch {
          }
        }
        const migrationHierarchy = availablePersistences.filter((p) => p._shouldAllowMigration);
        if (!selectedPersistence._shouldAllowMigration || !migrationHierarchy.length) {
          return new _PersistenceUserManager(selectedPersistence, auth2, userKey);
        }
        selectedPersistence = migrationHierarchy[0];
        if (userToMigrate) {
          await selectedPersistence._set(key, userToMigrate.toJSON());
        }
        await Promise.all(persistenceHierarchy.map(async (persistence) => {
          if (persistence !== selectedPersistence) {
            try {
              await persistence._remove(key);
            } catch {
            }
          }
        }));
        return new _PersistenceUserManager(selectedPersistence, auth2, userKey);
      }
    };
    function _getBrowserName2(userAgent) {
      const ua = userAgent.toLowerCase();
      if (ua.includes("opera/") || ua.includes("opr/") || ua.includes("opios/")) {
        return "Opera";
      } else if (_isIEMobile2(ua)) {
        return "IEMobile";
      } else if (ua.includes("msie") || ua.includes("trident/")) {
        return "IE";
      } else if (ua.includes("edge/")) {
        return "Edge";
      } else if (_isFirefox2(ua)) {
        return "Firefox";
      } else if (ua.includes("silk/")) {
        return "Silk";
      } else if (_isBlackBerry2(ua)) {
        return "Blackberry";
      } else if (_isWebOS2(ua)) {
        return "Webos";
      } else if (_isSafari2(ua)) {
        return "Safari";
      } else if ((ua.includes("chrome/") || _isChromeIOS2(ua)) && !ua.includes("edge/")) {
        return "Chrome";
      } else if (_isAndroid2(ua)) {
        return "Android";
      } else {
        const re = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/;
        const matches = userAgent.match(re);
        if (matches?.length === 2) {
          return matches[1];
        }
      }
      return "Other";
    }
    function _isFirefox2(ua = util.getUA()) {
      return /firefox\//i.test(ua);
    }
    function _isSafari2(userAgent = util.getUA()) {
      const ua = userAgent.toLowerCase();
      return ua.includes("safari/") && !ua.includes("chrome/") && !ua.includes("crios/") && !ua.includes("android");
    }
    function _isChromeIOS2(ua = util.getUA()) {
      return /crios\//i.test(ua);
    }
    function _isIEMobile2(ua = util.getUA()) {
      return /iemobile/i.test(ua);
    }
    function _isAndroid2(ua = util.getUA()) {
      return /android/i.test(ua);
    }
    function _isBlackBerry2(ua = util.getUA()) {
      return /blackberry/i.test(ua);
    }
    function _isWebOS2(ua = util.getUA()) {
      return /webos/i.test(ua);
    }
    function _isIOS(ua = util.getUA()) {
      return /iphone|ipad|ipod/i.test(ua) || /macintosh/i.test(ua) && /mobile/i.test(ua);
    }
    function _isIOS7Or8(ua = util.getUA()) {
      return /(iPad|iPhone|iPod).*OS 7_\d/i.test(ua) || /(iPad|iPhone|iPod).*OS 8_\d/i.test(ua);
    }
    function _isIE10() {
      return util.isIE() && document.documentMode === 10;
    }
    function _isMobileBrowser(ua = util.getUA()) {
      return _isIOS(ua) || _isAndroid2(ua) || _isWebOS2(ua) || _isBlackBerry2(ua) || /windows phone/i.test(ua) || _isIEMobile2(ua);
    }
    function _getClientVersion2(clientPlatform, frameworks = []) {
      let reportedPlatform;
      switch (clientPlatform) {
        case "Browser":
          reportedPlatform = _getBrowserName2(util.getUA());
          break;
        case "Worker":
          reportedPlatform = `${_getBrowserName2(util.getUA())}-${clientPlatform}`;
          break;
        default:
          reportedPlatform = clientPlatform;
      }
      const reportedFrameworks = frameworks.length ? frameworks.join(",") : "FirebaseCore-web";
      return `${reportedPlatform}/${"JsCore"}/${app2.SDK_VERSION}/${reportedFrameworks}`;
    }
    var AuthMiddlewareQueue2 = class {
      constructor(auth2) {
        this.auth = auth2;
        this.queue = [];
      }
      pushCallback(callback, onAbort) {
        const wrappedCallback = (user) => new Promise((resolve, reject) => {
          try {
            const result = callback(user);
            resolve(result);
          } catch (e) {
            reject(e);
          }
        });
        wrappedCallback.onAbort = onAbort;
        this.queue.push(wrappedCallback);
        const index = this.queue.length - 1;
        return () => {
          this.queue[index] = () => Promise.resolve();
        };
      }
      async runMiddleware(nextUser) {
        if (this.auth.currentUser === nextUser) {
          return;
        }
        const onAbortStack = [];
        try {
          for (const beforeStateCallback of this.queue) {
            await beforeStateCallback(nextUser);
            if (beforeStateCallback.onAbort) {
              onAbortStack.push(beforeStateCallback.onAbort);
            }
          }
        } catch (e) {
          onAbortStack.reverse();
          for (const onAbort of onAbortStack) {
            try {
              onAbort();
            } catch (_) {
            }
          }
          throw this.auth._errorFactory.create("login-blocked", {
            originalMessage: e?.message
          });
        }
      }
    };
    async function _getPasswordPolicy2(auth2, request = {}) {
      return _performApiRequest2(auth2, "GET", "/v2/passwordPolicy", _addTidIfNecessary2(auth2, request));
    }
    var MINIMUM_MIN_PASSWORD_LENGTH2 = 6;
    var PasswordPolicyImpl2 = class {
      constructor(response) {
        const responseOptions = response.customStrengthOptions;
        this.customStrengthOptions = {};
        this.customStrengthOptions.minPasswordLength = responseOptions.minPasswordLength ?? MINIMUM_MIN_PASSWORD_LENGTH2;
        if (responseOptions.maxPasswordLength) {
          this.customStrengthOptions.maxPasswordLength = responseOptions.maxPasswordLength;
        }
        if (responseOptions.containsLowercaseCharacter !== void 0) {
          this.customStrengthOptions.containsLowercaseLetter = responseOptions.containsLowercaseCharacter;
        }
        if (responseOptions.containsUppercaseCharacter !== void 0) {
          this.customStrengthOptions.containsUppercaseLetter = responseOptions.containsUppercaseCharacter;
        }
        if (responseOptions.containsNumericCharacter !== void 0) {
          this.customStrengthOptions.containsNumericCharacter = responseOptions.containsNumericCharacter;
        }
        if (responseOptions.containsNonAlphanumericCharacter !== void 0) {
          this.customStrengthOptions.containsNonAlphanumericCharacter = responseOptions.containsNonAlphanumericCharacter;
        }
        this.enforcementState = response.enforcementState;
        if (this.enforcementState === "ENFORCEMENT_STATE_UNSPECIFIED") {
          this.enforcementState = "OFF";
        }
        this.allowedNonAlphanumericCharacters = response.allowedNonAlphanumericCharacters?.join("") ?? "";
        this.forceUpgradeOnSignin = response.forceUpgradeOnSignin ?? false;
        this.schemaVersion = response.schemaVersion;
      }
      validatePassword(password) {
        const status = {
          isValid: true,
          passwordPolicy: this
        };
        this.validatePasswordLengthOptions(password, status);
        this.validatePasswordCharacterOptions(password, status);
        status.isValid && (status.isValid = status.meetsMinPasswordLength ?? true);
        status.isValid && (status.isValid = status.meetsMaxPasswordLength ?? true);
        status.isValid && (status.isValid = status.containsLowercaseLetter ?? true);
        status.isValid && (status.isValid = status.containsUppercaseLetter ?? true);
        status.isValid && (status.isValid = status.containsNumericCharacter ?? true);
        status.isValid && (status.isValid = status.containsNonAlphanumericCharacter ?? true);
        return status;
      }
      /**
       * Validates that the password meets the length options for the policy.
       *
       * @param password Password to validate.
       * @param status Validation status.
       */
      validatePasswordLengthOptions(password, status) {
        const minPasswordLength = this.customStrengthOptions.minPasswordLength;
        const maxPasswordLength = this.customStrengthOptions.maxPasswordLength;
        if (minPasswordLength) {
          status.meetsMinPasswordLength = password.length >= minPasswordLength;
        }
        if (maxPasswordLength) {
          status.meetsMaxPasswordLength = password.length <= maxPasswordLength;
        }
      }
      /**
       * Validates that the password meets the character options for the policy.
       *
       * @param password Password to validate.
       * @param status Validation status.
       */
      validatePasswordCharacterOptions(password, status) {
        this.updatePasswordCharacterOptionsStatuses(
          status,
          /* containsLowercaseCharacter= */
          false,
          /* containsUppercaseCharacter= */
          false,
          /* containsNumericCharacter= */
          false,
          /* containsNonAlphanumericCharacter= */
          false
        );
        let passwordChar;
        for (let i = 0; i < password.length; i++) {
          passwordChar = password.charAt(i);
          this.updatePasswordCharacterOptionsStatuses(
            status,
            /* containsLowercaseCharacter= */
            passwordChar >= "a" && passwordChar <= "z",
            /* containsUppercaseCharacter= */
            passwordChar >= "A" && passwordChar <= "Z",
            /* containsNumericCharacter= */
            passwordChar >= "0" && passwordChar <= "9",
            /* containsNonAlphanumericCharacter= */
            this.allowedNonAlphanumericCharacters.includes(passwordChar)
          );
        }
      }
      /**
       * Updates the running validation status with the statuses for the character options.
       * Expected to be called each time a character is processed to update each option status
       * based on the current character.
       *
       * @param status Validation status.
       * @param containsLowercaseCharacter Whether the character is a lowercase letter.
       * @param containsUppercaseCharacter Whether the character is an uppercase letter.
       * @param containsNumericCharacter Whether the character is a numeric character.
       * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.
       */
      updatePasswordCharacterOptionsStatuses(status, containsLowercaseCharacter, containsUppercaseCharacter, containsNumericCharacter, containsNonAlphanumericCharacter) {
        if (this.customStrengthOptions.containsLowercaseLetter) {
          status.containsLowercaseLetter || (status.containsLowercaseLetter = containsLowercaseCharacter);
        }
        if (this.customStrengthOptions.containsUppercaseLetter) {
          status.containsUppercaseLetter || (status.containsUppercaseLetter = containsUppercaseCharacter);
        }
        if (this.customStrengthOptions.containsNumericCharacter) {
          status.containsNumericCharacter || (status.containsNumericCharacter = containsNumericCharacter);
        }
        if (this.customStrengthOptions.containsNonAlphanumericCharacter) {
          status.containsNonAlphanumericCharacter || (status.containsNonAlphanumericCharacter = containsNonAlphanumericCharacter);
        }
      }
    };
    var AuthImpl2 = class {
      constructor(app3, heartbeatServiceProvider, appCheckServiceProvider, config) {
        this.app = app3;
        this.heartbeatServiceProvider = heartbeatServiceProvider;
        this.appCheckServiceProvider = appCheckServiceProvider;
        this.config = config;
        this.currentUser = null;
        this.emulatorConfig = null;
        this.operations = Promise.resolve();
        this.authStateSubscription = new Subscription2(this);
        this.idTokenSubscription = new Subscription2(this);
        this.beforeStateQueue = new AuthMiddlewareQueue2(this);
        this.redirectUser = null;
        this.isProactiveRefreshEnabled = false;
        this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION = 1;
        this._canInitEmulator = true;
        this._isInitialized = false;
        this._deleted = false;
        this._initializationPromise = null;
        this._popupRedirectResolver = null;
        this._errorFactory = _DEFAULT_AUTH_ERROR_FACTORY2;
        this._agentRecaptchaConfig = null;
        this._tenantRecaptchaConfigs = {};
        this._projectPasswordPolicy = null;
        this._tenantPasswordPolicies = {};
        this._resolvePersistenceManagerAvailable = void 0;
        this.lastNotifiedUid = void 0;
        this.languageCode = null;
        this.tenantId = null;
        this.settings = { appVerificationDisabledForTesting: false };
        this.frameworks = [];
        this.name = app3.name;
        this.clientVersion = config.sdkClientVersion;
        this._persistenceManagerAvailable = new Promise((resolve) => this._resolvePersistenceManagerAvailable = resolve);
      }
      _initializeWithPersistence(persistenceHierarchy, popupRedirectResolver) {
        if (popupRedirectResolver) {
          this._popupRedirectResolver = _getInstance2(popupRedirectResolver);
        }
        this._initializationPromise = this.queue(async () => {
          if (this._deleted) {
            return;
          }
          this.persistenceManager = await PersistenceUserManager2.create(this, persistenceHierarchy);
          this._resolvePersistenceManagerAvailable?.();
          if (this._deleted) {
            return;
          }
          if (this._popupRedirectResolver?._shouldInitProactively) {
            try {
              await this._popupRedirectResolver._initialize(this);
            } catch (e) {
            }
          }
          await this.initializeCurrentUser(popupRedirectResolver);
          this.lastNotifiedUid = this.currentUser?.uid || null;
          if (this._deleted) {
            return;
          }
          this._isInitialized = true;
        });
        return this._initializationPromise;
      }
      /**
       * If the persistence is changed in another window, the user manager will let us know
       */
      async _onStorageEvent() {
        if (this._deleted) {
          return;
        }
        const user = await this.assertedPersistence.getCurrentUser();
        if (!this.currentUser && !user) {
          return;
        }
        if (this.currentUser && user && this.currentUser.uid === user.uid) {
          this._currentUser._assign(user);
          await this.currentUser.getIdToken();
          return;
        }
        await this._updateCurrentUser(
          user,
          /* skipBeforeStateCallbacks */
          true
        );
      }
      async initializeCurrentUserFromIdToken(idToken) {
        try {
          const response = await getAccountInfo2(this, { idToken });
          const user = await UserImpl2._fromGetAccountInfoResponse(this, response, idToken);
          await this.directlySetCurrentUser(user);
        } catch (err) {
          console.warn("FirebaseServerApp could not login user with provided authIdToken: ", err);
          await this.directlySetCurrentUser(null);
        }
      }
      async initializeCurrentUser(popupRedirectResolver) {
        if (app2._isFirebaseServerApp(this.app)) {
          const idToken = this.app.settings.authIdToken;
          if (idToken) {
            return new Promise((resolve) => {
              setTimeout(() => this.initializeCurrentUserFromIdToken(idToken).then(resolve, resolve));
            });
          } else {
            return this.directlySetCurrentUser(null);
          }
        }
        const previouslyStoredUser = await this.assertedPersistence.getCurrentUser();
        let futureCurrentUser = previouslyStoredUser;
        let needsTocheckMiddleware = false;
        if (popupRedirectResolver && this.config.authDomain) {
          await this.getOrInitRedirectPersistenceManager();
          const redirectUserEventId = this.redirectUser?._redirectEventId;
          const storedUserEventId = futureCurrentUser?._redirectEventId;
          const result = await this.tryRedirectSignIn(popupRedirectResolver);
          if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) && result?.user) {
            futureCurrentUser = result.user;
            needsTocheckMiddleware = true;
          }
        }
        if (!futureCurrentUser) {
          return this.directlySetCurrentUser(null);
        }
        if (!futureCurrentUser._redirectEventId) {
          if (needsTocheckMiddleware) {
            try {
              await this.beforeStateQueue.runMiddleware(futureCurrentUser);
            } catch (e) {
              futureCurrentUser = previouslyStoredUser;
              this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(e));
            }
          }
          if (futureCurrentUser) {
            return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
          } else {
            return this.directlySetCurrentUser(null);
          }
        }
        _assert2(
          this._popupRedirectResolver,
          this,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        await this.getOrInitRedirectPersistenceManager();
        if (this.redirectUser && this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
          return this.directlySetCurrentUser(futureCurrentUser);
        }
        return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
      }
      async tryRedirectSignIn(redirectResolver) {
        let result = null;
        try {
          result = await this._popupRedirectResolver._completeRedirectFn(this, redirectResolver, true);
        } catch (e) {
          await this._setRedirectUser(null);
        }
        return result;
      }
      async reloadAndSetCurrentUserOrClear(user) {
        try {
          await _reloadWithoutSaving2(user);
        } catch (e) {
          if (e?.code !== `auth/${"network-request-failed"}`) {
            return this.directlySetCurrentUser(null);
          }
        }
        return this.directlySetCurrentUser(user);
      }
      useDeviceLanguage() {
        this.languageCode = _getUserLanguage2();
      }
      async _delete() {
        this._deleted = true;
      }
      async updateCurrentUser(userExtern) {
        if (app2._isFirebaseServerApp(this.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(this));
        }
        const user = userExtern ? util.getModularInstance(userExtern) : null;
        if (user) {
          _assert2(
            user.auth.config.apiKey === this.config.apiKey,
            this,
            "invalid-user-token"
            /* AuthErrorCode.INVALID_AUTH */
          );
        }
        return this._updateCurrentUser(user && user._clone(this));
      }
      async _updateCurrentUser(user, skipBeforeStateCallbacks = false) {
        if (this._deleted) {
          return;
        }
        if (user) {
          _assert2(
            this.tenantId === user.tenantId,
            this,
            "tenant-id-mismatch"
            /* AuthErrorCode.TENANT_ID_MISMATCH */
          );
        }
        if (!skipBeforeStateCallbacks) {
          await this.beforeStateQueue.runMiddleware(user);
        }
        return this.queue(async () => {
          await this.directlySetCurrentUser(user);
          this.notifyAuthListeners();
        });
      }
      async signOut() {
        if (app2._isFirebaseServerApp(this.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(this));
        }
        await this.beforeStateQueue.runMiddleware(null);
        if (this.redirectPersistenceManager || this._popupRedirectResolver) {
          await this._setRedirectUser(null);
        }
        return this._updateCurrentUser(
          null,
          /* skipBeforeStateCallbacks */
          true
        );
      }
      setPersistence(persistence) {
        if (app2._isFirebaseServerApp(this.app)) {
          return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(this));
        }
        return this.queue(async () => {
          await this.assertedPersistence.setPersistence(_getInstance2(persistence));
        });
      }
      _getRecaptchaConfig() {
        if (this.tenantId == null) {
          return this._agentRecaptchaConfig;
        } else {
          return this._tenantRecaptchaConfigs[this.tenantId];
        }
      }
      async validatePassword(password) {
        if (!this._getPasswordPolicyInternal()) {
          await this._updatePasswordPolicy();
        }
        const passwordPolicy = this._getPasswordPolicyInternal();
        if (passwordPolicy.schemaVersion !== this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION) {
          return Promise.reject(this._errorFactory.create("unsupported-password-policy-schema-version", {}));
        }
        return passwordPolicy.validatePassword(password);
      }
      _getPasswordPolicyInternal() {
        if (this.tenantId === null) {
          return this._projectPasswordPolicy;
        } else {
          return this._tenantPasswordPolicies[this.tenantId];
        }
      }
      async _updatePasswordPolicy() {
        const response = await _getPasswordPolicy2(this);
        const passwordPolicy = new PasswordPolicyImpl2(response);
        if (this.tenantId === null) {
          this._projectPasswordPolicy = passwordPolicy;
        } else {
          this._tenantPasswordPolicies[this.tenantId] = passwordPolicy;
        }
      }
      _getPersistenceType() {
        return this.assertedPersistence.persistence.type;
      }
      _getPersistence() {
        return this.assertedPersistence.persistence;
      }
      _updateErrorMap(errorMap) {
        this._errorFactory = new util.ErrorFactory("auth", "Firebase", errorMap());
      }
      onAuthStateChanged(nextOrObserver, error, completed) {
        return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
      }
      beforeAuthStateChanged(callback, onAbort) {
        return this.beforeStateQueue.pushCallback(callback, onAbort);
      }
      onIdTokenChanged(nextOrObserver, error, completed) {
        return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
      }
      authStateReady() {
        return new Promise((resolve, reject) => {
          if (this.currentUser) {
            resolve();
          } else {
            const unsubscribe = this.onAuthStateChanged(() => {
              unsubscribe();
              resolve();
            }, reject);
          }
        });
      }
      /**
       * Revokes the given access token. Currently only supports Apple OAuth access tokens.
       */
      async revokeAccessToken(token) {
        if (this.currentUser) {
          const idToken = await this.currentUser.getIdToken();
          const request = {
            providerId: "apple.com",
            tokenType: "ACCESS_TOKEN",
            token,
            idToken
          };
          if (this.tenantId != null) {
            request.tenantId = this.tenantId;
          }
          await revokeToken2(this, request);
        }
      }
      toJSON() {
        return {
          apiKey: this.config.apiKey,
          authDomain: this.config.authDomain,
          appName: this.name,
          currentUser: this._currentUser?.toJSON()
        };
      }
      async _setRedirectUser(user, popupRedirectResolver) {
        const redirectManager = await this.getOrInitRedirectPersistenceManager(popupRedirectResolver);
        return user === null ? redirectManager.removeCurrentUser() : redirectManager.setCurrentUser(user);
      }
      async getOrInitRedirectPersistenceManager(popupRedirectResolver) {
        if (!this.redirectPersistenceManager) {
          const resolver = popupRedirectResolver && _getInstance2(popupRedirectResolver) || this._popupRedirectResolver;
          _assert2(
            resolver,
            this,
            "argument-error"
            /* AuthErrorCode.ARGUMENT_ERROR */
          );
          this.redirectPersistenceManager = await PersistenceUserManager2.create(
            this,
            [_getInstance2(resolver._redirectPersistence)],
            "redirectUser"
            /* KeyName.REDIRECT_USER */
          );
          this.redirectUser = await this.redirectPersistenceManager.getCurrentUser();
        }
        return this.redirectPersistenceManager;
      }
      async _redirectUserForId(id) {
        if (this._isInitialized) {
          await this.queue(async () => {
          });
        }
        if (this._currentUser?._redirectEventId === id) {
          return this._currentUser;
        }
        if (this.redirectUser?._redirectEventId === id) {
          return this.redirectUser;
        }
        return null;
      }
      async _persistUserIfCurrent(user) {
        if (user === this.currentUser) {
          return this.queue(async () => this.directlySetCurrentUser(user));
        }
      }
      /** Notifies listeners only if the user is current */
      _notifyListenersIfCurrent(user) {
        if (user === this.currentUser) {
          this.notifyAuthListeners();
        }
      }
      _key() {
        return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;
      }
      _startProactiveRefresh() {
        this.isProactiveRefreshEnabled = true;
        if (this.currentUser) {
          this._currentUser._startProactiveRefresh();
        }
      }
      _stopProactiveRefresh() {
        this.isProactiveRefreshEnabled = false;
        if (this.currentUser) {
          this._currentUser._stopProactiveRefresh();
        }
      }
      /** Returns the current user cast as the internal type */
      get _currentUser() {
        return this.currentUser;
      }
      notifyAuthListeners() {
        if (!this._isInitialized) {
          return;
        }
        this.idTokenSubscription.next(this.currentUser);
        const currentUid = this.currentUser?.uid ?? null;
        if (this.lastNotifiedUid !== currentUid) {
          this.lastNotifiedUid = currentUid;
          this.authStateSubscription.next(this.currentUser);
        }
      }
      registerStateListener(subscription, nextOrObserver, error, completed) {
        if (this._deleted) {
          return () => {
          };
        }
        const cb = typeof nextOrObserver === "function" ? nextOrObserver : nextOrObserver.next.bind(nextOrObserver);
        let isUnsubscribed = false;
        const promise = this._isInitialized ? Promise.resolve() : this._initializationPromise;
        _assert2(
          promise,
          this,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        promise.then(() => {
          if (isUnsubscribed) {
            return;
          }
          cb(this.currentUser);
        });
        if (typeof nextOrObserver === "function") {
          const unsubscribe = subscription.addObserver(nextOrObserver, error, completed);
          return () => {
            isUnsubscribed = true;
            unsubscribe();
          };
        } else {
          const unsubscribe = subscription.addObserver(nextOrObserver);
          return () => {
            isUnsubscribed = true;
            unsubscribe();
          };
        }
      }
      /**
       * Unprotected (from race conditions) method to set the current user. This
       * should only be called from within a queued callback. This is necessary
       * because the queue shouldn't rely on another queued callback.
       */
      async directlySetCurrentUser(user) {
        if (this.currentUser && this.currentUser !== user) {
          this._currentUser._stopProactiveRefresh();
        }
        if (user && this.isProactiveRefreshEnabled) {
          user._startProactiveRefresh();
        }
        this.currentUser = user;
        if (user) {
          await this.assertedPersistence.setCurrentUser(user);
        } else {
          await this.assertedPersistence.removeCurrentUser();
        }
      }
      queue(action) {
        this.operations = this.operations.then(action, action);
        return this.operations;
      }
      get assertedPersistence() {
        _assert2(
          this.persistenceManager,
          this,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        return this.persistenceManager;
      }
      _logFramework(framework) {
        if (!framework || this.frameworks.includes(framework)) {
          return;
        }
        this.frameworks.push(framework);
        this.frameworks.sort();
        this.clientVersion = _getClientVersion2(this.config.clientPlatform, this._getFrameworks());
      }
      _getFrameworks() {
        return this.frameworks;
      }
      async _getAdditionalHeaders() {
        const headers = {
          [
            "X-Client-Version"
            /* HttpHeader.X_CLIENT_VERSION */
          ]: this.clientVersion
        };
        if (this.app.options.appId) {
          headers[
            "X-Firebase-gmpid"
            /* HttpHeader.X_FIREBASE_GMPID */
          ] = this.app.options.appId;
        }
        const heartbeatsHeader = await this.heartbeatServiceProvider.getImmediate({
          optional: true
        })?.getHeartbeatsHeader();
        if (heartbeatsHeader) {
          headers[
            "X-Firebase-Client"
            /* HttpHeader.X_FIREBASE_CLIENT */
          ] = heartbeatsHeader;
        }
        const appCheckToken = await this._getAppCheckToken();
        if (appCheckToken) {
          headers[
            "X-Firebase-AppCheck"
            /* HttpHeader.X_FIREBASE_APP_CHECK */
          ] = appCheckToken;
        }
        return headers;
      }
      async _getAppCheckToken() {
        if (app2._isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {
          return this.app.settings.appCheckToken;
        }
        const appCheckTokenResult = await this.appCheckServiceProvider.getImmediate({ optional: true })?.getToken();
        if (appCheckTokenResult?.error) {
          _logWarn2(`Error while retrieving App Check token: ${appCheckTokenResult.error}`);
        }
        return appCheckTokenResult?.token;
      }
    };
    function _castAuth2(auth2) {
      return util.getModularInstance(auth2);
    }
    var Subscription2 = class {
      constructor(auth2) {
        this.auth = auth2;
        this.observer = null;
        this.addObserver = util.createSubscribe((observer) => this.observer = observer);
      }
      get next() {
        _assert2(
          this.observer,
          this.auth,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        return this.observer.next.bind(this.observer);
      }
    };
    var externalJSProvider2 = {
      async loadJS() {
        throw new Error("Unable to load external scripts");
      },
      recaptchaV2Script: "",
      recaptchaEnterpriseScript: "",
      gapiScript: ""
    };
    function _loadJS2(url) {
      return externalJSProvider2.loadJS(url);
    }
    function _recaptchaEnterpriseScriptUrl2() {
      return externalJSProvider2.recaptchaEnterpriseScript;
    }
    var MockGreCAPTCHATopLevel2 = class {
      constructor() {
        this.enterprise = new MockGreCAPTCHA2();
      }
      ready(callback) {
        callback();
      }
      execute(_siteKey, _options) {
        return Promise.resolve("token");
      }
      render(_container, _parameters) {
        return "";
      }
    };
    var MockGreCAPTCHA2 = class {
      ready(callback) {
        callback();
      }
      execute(_siteKey, _options) {
        return Promise.resolve("token");
      }
      render(_container, _parameters) {
        return "";
      }
    };
    var RECAPTCHA_ENTERPRISE_VERIFIER_TYPE2 = "recaptcha-enterprise";
    var FAKE_TOKEN2 = "NO_RECAPTCHA";
    var RecaptchaEnterpriseVerifier2 = class {
      /**
       *
       * @param authExtern - The corresponding Firebase {@link Auth} instance.
       *
       */
      constructor(authExtern) {
        this.type = RECAPTCHA_ENTERPRISE_VERIFIER_TYPE2;
        this.auth = _castAuth2(authExtern);
      }
      /**
       * Executes the verification process.
       *
       * @returns A Promise for a token that can be used to assert the validity of a request.
       */
      async verify(action = "verify", forceRefresh = false) {
        async function retrieveSiteKey(auth2) {
          if (!forceRefresh) {
            if (auth2.tenantId == null && auth2._agentRecaptchaConfig != null) {
              return auth2._agentRecaptchaConfig.siteKey;
            }
            if (auth2.tenantId != null && auth2._tenantRecaptchaConfigs[auth2.tenantId] !== void 0) {
              return auth2._tenantRecaptchaConfigs[auth2.tenantId].siteKey;
            }
          }
          return new Promise(async (resolve, reject) => {
            getRecaptchaConfig2(auth2, {
              clientType: "CLIENT_TYPE_WEB",
              version: "RECAPTCHA_ENTERPRISE"
              /* RecaptchaVersion.ENTERPRISE */
            }).then((response) => {
              if (response.recaptchaKey === void 0) {
                reject(new Error("recaptcha Enterprise site key undefined"));
              } else {
                const config = new RecaptchaConfig2(response);
                if (auth2.tenantId == null) {
                  auth2._agentRecaptchaConfig = config;
                } else {
                  auth2._tenantRecaptchaConfigs[auth2.tenantId] = config;
                }
                return resolve(config.siteKey);
              }
            }).catch((error) => {
              reject(error);
            });
          });
        }
        function retrieveRecaptchaToken(siteKey, resolve, reject) {
          const grecaptcha = window.grecaptcha;
          if (isEnterprise2(grecaptcha)) {
            grecaptcha.enterprise.ready(() => {
              grecaptcha.enterprise.execute(siteKey, { action }).then((token) => {
                resolve(token);
              }).catch(() => {
                resolve(FAKE_TOKEN2);
              });
            });
          } else {
            reject(Error("No reCAPTCHA enterprise script loaded."));
          }
        }
        if (this.auth.settings.appVerificationDisabledForTesting) {
          const mockRecaptcha = new MockGreCAPTCHATopLevel2();
          return mockRecaptcha.execute("siteKey", { action: "verify" });
        }
        return new Promise((resolve, reject) => {
          retrieveSiteKey(this.auth).then((siteKey) => {
            if (!forceRefresh && isEnterprise2(window.grecaptcha)) {
              retrieveRecaptchaToken(siteKey, resolve, reject);
            } else {
              if (typeof window === "undefined") {
                reject(new Error("RecaptchaVerifier is only supported in browser"));
                return;
              }
              let url = _recaptchaEnterpriseScriptUrl2();
              if (url.length !== 0) {
                url += siteKey;
              }
              _loadJS2(url).then(() => {
                retrieveRecaptchaToken(siteKey, resolve, reject);
              }).catch((error) => {
                reject(error);
              });
            }
          }).catch((error) => {
            reject(error);
          });
        });
      }
    };
    async function injectRecaptchaFields2(auth2, request, action, isCaptchaResp = false, isFakeToken = false) {
      const verifier = new RecaptchaEnterpriseVerifier2(auth2);
      let captchaResponse;
      if (isFakeToken) {
        captchaResponse = FAKE_TOKEN2;
      } else {
        try {
          captchaResponse = await verifier.verify(action);
        } catch (error) {
          captchaResponse = await verifier.verify(action, true);
        }
      }
      const newRequest = { ...request };
      if (action === "mfaSmsEnrollment" || action === "mfaSmsSignIn") {
        if ("phoneEnrollmentInfo" in newRequest) {
          const phoneNumber = newRequest.phoneEnrollmentInfo.phoneNumber;
          const recaptchaToken = newRequest.phoneEnrollmentInfo.recaptchaToken;
          Object.assign(newRequest, {
            "phoneEnrollmentInfo": {
              phoneNumber,
              recaptchaToken,
              captchaResponse,
              "clientType": "CLIENT_TYPE_WEB",
              "recaptchaVersion": "RECAPTCHA_ENTERPRISE"
              /* RecaptchaVersion.ENTERPRISE */
            }
          });
        } else if ("phoneSignInInfo" in newRequest) {
          const recaptchaToken = newRequest.phoneSignInInfo.recaptchaToken;
          Object.assign(newRequest, {
            "phoneSignInInfo": {
              recaptchaToken,
              captchaResponse,
              "clientType": "CLIENT_TYPE_WEB",
              "recaptchaVersion": "RECAPTCHA_ENTERPRISE"
              /* RecaptchaVersion.ENTERPRISE */
            }
          });
        }
        return newRequest;
      }
      if (!isCaptchaResp) {
        Object.assign(newRequest, { captchaResponse });
      } else {
        Object.assign(newRequest, { "captchaResp": captchaResponse });
      }
      Object.assign(newRequest, {
        "clientType": "CLIENT_TYPE_WEB"
        /* RecaptchaClientType.WEB */
      });
      Object.assign(newRequest, {
        "recaptchaVersion": "RECAPTCHA_ENTERPRISE"
        /* RecaptchaVersion.ENTERPRISE */
      });
      return newRequest;
    }
    async function handleRecaptchaFlow2(authInstance, request, actionName, actionMethod, recaptchaAuthProvider) {
      if (recaptchaAuthProvider === "EMAIL_PASSWORD_PROVIDER") {
        if (authInstance._getRecaptchaConfig()?.isProviderEnabled(
          "EMAIL_PASSWORD_PROVIDER"
          /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
        )) {
          const requestWithRecaptcha = await injectRecaptchaFields2(
            authInstance,
            request,
            actionName,
            actionName === "getOobCode"
            /* RecaptchaActionName.GET_OOB_CODE */
          );
          return actionMethod(authInstance, requestWithRecaptcha);
        } else {
          return actionMethod(authInstance, request).catch(async (error) => {
            if (error.code === `auth/${"missing-recaptcha-token"}`) {
              console.log(`${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`);
              const requestWithRecaptcha = await injectRecaptchaFields2(
                authInstance,
                request,
                actionName,
                actionName === "getOobCode"
                /* RecaptchaActionName.GET_OOB_CODE */
              );
              return actionMethod(authInstance, requestWithRecaptcha);
            } else {
              return Promise.reject(error);
            }
          });
        }
      } else if (recaptchaAuthProvider === "PHONE_PROVIDER") {
        if (authInstance._getRecaptchaConfig()?.isProviderEnabled(
          "PHONE_PROVIDER"
          /* RecaptchaAuthProvider.PHONE_PROVIDER */
        )) {
          const requestWithRecaptcha = await injectRecaptchaFields2(authInstance, request, actionName);
          return actionMethod(authInstance, requestWithRecaptcha).catch(async (error) => {
            if (authInstance._getRecaptchaConfig()?.getProviderEnforcementState(
              "PHONE_PROVIDER"
              /* RecaptchaAuthProvider.PHONE_PROVIDER */
            ) === "AUDIT") {
              if (error.code === `auth/${"missing-recaptcha-token"}` || error.code === `auth/${"invalid-app-credential"}`) {
                console.log(`Failed to verify with reCAPTCHA Enterprise. Automatically triggering the reCAPTCHA v2 flow to complete the ${actionName} flow.`);
                const requestWithRecaptchaFields = await injectRecaptchaFields2(
                  authInstance,
                  request,
                  actionName,
                  false,
                  // isCaptchaResp
                  true
                  // isFakeToken
                );
                return actionMethod(authInstance, requestWithRecaptchaFields);
              }
            }
            return Promise.reject(error);
          });
        } else {
          const requestWithRecaptchaFields = await injectRecaptchaFields2(
            authInstance,
            request,
            actionName,
            false,
            // isCaptchaResp
            true
            // isFakeToken
          );
          return actionMethod(authInstance, requestWithRecaptchaFields);
        }
      } else {
        return Promise.reject(recaptchaAuthProvider + " provider is not supported.");
      }
    }
    async function _initializeRecaptchaConfig2(auth2) {
      const authInternal = _castAuth2(auth2);
      const response = await getRecaptchaConfig2(authInternal, {
        clientType: "CLIENT_TYPE_WEB",
        version: "RECAPTCHA_ENTERPRISE"
        /* RecaptchaVersion.ENTERPRISE */
      });
      const config = new RecaptchaConfig2(response);
      if (authInternal.tenantId == null) {
        authInternal._agentRecaptchaConfig = config;
      } else {
        authInternal._tenantRecaptchaConfigs[authInternal.tenantId] = config;
      }
      if (config.isAnyProviderEnabled()) {
        const verifier = new RecaptchaEnterpriseVerifier2(authInternal);
        void verifier.verify();
      }
    }
    function initializeAuth2(app$1, deps) {
      const provider = app2._getProvider(app$1, "auth");
      if (provider.isInitialized()) {
        const auth3 = provider.getImmediate();
        const initialOptions = provider.getOptions();
        if (util.deepEqual(initialOptions, deps ?? {})) {
          return auth3;
        } else {
          _fail2(
            auth3,
            "already-initialized"
            /* AuthErrorCode.ALREADY_INITIALIZED */
          );
        }
      }
      const auth2 = provider.initialize({ options: deps });
      return auth2;
    }
    function _initializeAuthInstance2(auth2, deps) {
      const persistence = deps?.persistence || [];
      const hierarchy = (Array.isArray(persistence) ? persistence : [persistence]).map(_getInstance2);
      if (deps?.errorMap) {
        auth2._updateErrorMap(deps.errorMap);
      }
      auth2._initializeWithPersistence(hierarchy, deps?.popupRedirectResolver);
    }
    function connectAuthEmulator2(auth2, url, options) {
      const authInternal = _castAuth2(auth2);
      _assert2(
        /^https?:\/\//.test(url),
        authInternal,
        "invalid-emulator-scheme"
        /* AuthErrorCode.INVALID_EMULATOR_SCHEME */
      );
      const disableWarnings = !!options?.disableWarnings;
      const protocol = extractProtocol2(url);
      const { host, port } = extractHostAndPort2(url);
      const portStr = port === null ? "" : `:${port}`;
      const emulator = { url: `${protocol}//${host}${portStr}/` };
      const emulatorConfig = Object.freeze({
        host,
        port,
        protocol: protocol.replace(":", ""),
        options: Object.freeze({ disableWarnings })
      });
      if (!authInternal._canInitEmulator) {
        _assert2(
          authInternal.config.emulator && authInternal.emulatorConfig,
          authInternal,
          "emulator-config-failed"
          /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
        );
        _assert2(
          util.deepEqual(emulator, authInternal.config.emulator) && util.deepEqual(emulatorConfig, authInternal.emulatorConfig),
          authInternal,
          "emulator-config-failed"
          /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
        );
        return;
      }
      authInternal.config.emulator = emulator;
      authInternal.emulatorConfig = emulatorConfig;
      authInternal.settings.appVerificationDisabledForTesting = true;
      if (util.isCloudWorkstation(host)) {
        void util.pingServer(`${protocol}//${host}${portStr}`);
        util.updateEmulatorBanner("Auth", true);
      } else if (!disableWarnings) {
        emitEmulatorWarning2();
      }
    }
    function extractProtocol2(url) {
      const protocolEnd = url.indexOf(":");
      return protocolEnd < 0 ? "" : url.substr(0, protocolEnd + 1);
    }
    function extractHostAndPort2(url) {
      const protocol = extractProtocol2(url);
      const authority = /(\/\/)?([^?#/]+)/.exec(url.substr(protocol.length));
      if (!authority) {
        return { host: "", port: null };
      }
      const hostAndPort = authority[2].split("@").pop() || "";
      const bracketedIPv6 = /^(\[[^\]]+\])(:|$)/.exec(hostAndPort);
      if (bracketedIPv6) {
        const host = bracketedIPv6[1];
        return { host, port: parsePort2(hostAndPort.substr(host.length + 1)) };
      } else {
        const [host, port] = hostAndPort.split(":");
        return { host, port: parsePort2(port) };
      }
    }
    function parsePort2(portStr) {
      if (!portStr) {
        return null;
      }
      const port = Number(portStr);
      if (isNaN(port)) {
        return null;
      }
      return port;
    }
    function emitEmulatorWarning2() {
      function attachBanner() {
        const el = document.createElement("p");
        const sty = el.style;
        el.innerText = "Running in emulator mode. Do not use with production credentials.";
        sty.position = "fixed";
        sty.width = "100%";
        sty.backgroundColor = "#ffffff";
        sty.border = ".1em solid #000000";
        sty.color = "#b50000";
        sty.bottom = "0px";
        sty.left = "0px";
        sty.margin = "0px";
        sty.zIndex = "10000";
        sty.textAlign = "center";
        el.classList.add("firebase-emulator-warning");
        document.body.appendChild(el);
      }
      if (typeof console !== "undefined" && typeof console.info === "function") {
        console.info("WARNING: You are using the Auth Emulator, which is intended for local testing only.  Do not use with production credentials.");
      }
      if (typeof window !== "undefined" && typeof document !== "undefined") {
        if (document.readyState === "loading") {
          window.addEventListener("DOMContentLoaded", attachBanner);
        } else {
          attachBanner();
        }
      }
    }
    var AuthCredential2 = class {
      /** @internal */
      constructor(providerId, signInMethod) {
        this.providerId = providerId;
        this.signInMethod = signInMethod;
      }
      /**
       * Returns a JSON-serializable representation of this object.
       *
       * @returns a JSON-serializable representation of this object.
       */
      toJSON() {
        return debugFail2("not implemented");
      }
      /** @internal */
      _getIdTokenResponse(_auth) {
        return debugFail2("not implemented");
      }
      /** @internal */
      _linkToIdToken(_auth, _idToken) {
        return debugFail2("not implemented");
      }
      /** @internal */
      _getReauthenticationResolver(_auth) {
        return debugFail2("not implemented");
      }
    };
    async function resetPassword2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:resetPassword", _addTidIfNecessary2(auth2, request));
    }
    async function updateEmailPassword2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:update", request);
    }
    async function linkEmailPassword2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:signUp", request);
    }
    async function applyActionCode$12(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:update", _addTidIfNecessary2(auth2, request));
    }
    async function signInWithPassword2(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithPassword", _addTidIfNecessary2(auth2, request));
    }
    async function sendOobCode2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:sendOobCode", _addTidIfNecessary2(auth2, request));
    }
    async function sendEmailVerification$12(auth2, request) {
      return sendOobCode2(auth2, request);
    }
    async function sendPasswordResetEmail$12(auth2, request) {
      return sendOobCode2(auth2, request);
    }
    async function sendSignInLinkToEmail$12(auth2, request) {
      return sendOobCode2(auth2, request);
    }
    async function verifyAndChangeEmail2(auth2, request) {
      return sendOobCode2(auth2, request);
    }
    async function signInWithEmailLink$12(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary2(auth2, request));
    }
    async function signInWithEmailLinkForLinking2(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithEmailLink", _addTidIfNecessary2(auth2, request));
    }
    var EmailAuthCredential2 = class _EmailAuthCredential extends AuthCredential2 {
      /** @internal */
      constructor(_email, _password, signInMethod, _tenantId = null) {
        super("password", signInMethod);
        this._email = _email;
        this._password = _password;
        this._tenantId = _tenantId;
      }
      /** @internal */
      static _fromEmailAndPassword(email, password) {
        return new _EmailAuthCredential(
          email,
          password,
          "password"
          /* SignInMethod.EMAIL_PASSWORD */
        );
      }
      /** @internal */
      static _fromEmailAndCode(email, oobCode, tenantId = null) {
        return new _EmailAuthCredential(email, oobCode, "emailLink", tenantId);
      }
      /** {@inheritdoc AuthCredential.toJSON} */
      toJSON() {
        return {
          email: this._email,
          password: this._password,
          signInMethod: this.signInMethod,
          tenantId: this._tenantId
        };
      }
      /**
       * Static method to deserialize a JSON representation of an object into an {@link  AuthCredential}.
       *
       * @param json - Either `object` or the stringified representation of the object. When string is
       * provided, `JSON.parse` would be called first.
       *
       * @returns If the JSON input does not represent an {@link AuthCredential}, null is returned.
       */
      static fromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        if (obj?.email && obj?.password) {
          if (obj.signInMethod === "password") {
            return this._fromEmailAndPassword(obj.email, obj.password);
          } else if (obj.signInMethod === "emailLink") {
            return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);
          }
        }
        return null;
      }
      /** @internal */
      async _getIdTokenResponse(auth2) {
        switch (this.signInMethod) {
          case "password":
            const request = {
              returnSecureToken: true,
              email: this._email,
              password: this._password,
              clientType: "CLIENT_TYPE_WEB"
              /* RecaptchaClientType.WEB */
            };
            return handleRecaptchaFlow2(
              auth2,
              request,
              "signInWithPassword",
              signInWithPassword2,
              "EMAIL_PASSWORD_PROVIDER"
              /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
            );
          case "emailLink":
            return signInWithEmailLink$12(auth2, {
              email: this._email,
              oobCode: this._password
            });
          default:
            _fail2(
              auth2,
              "internal-error"
              /* AuthErrorCode.INTERNAL_ERROR */
            );
        }
      }
      /** @internal */
      async _linkToIdToken(auth2, idToken) {
        switch (this.signInMethod) {
          case "password":
            const request = {
              idToken,
              returnSecureToken: true,
              email: this._email,
              password: this._password,
              clientType: "CLIENT_TYPE_WEB"
              /* RecaptchaClientType.WEB */
            };
            return handleRecaptchaFlow2(
              auth2,
              request,
              "signUpPassword",
              linkEmailPassword2,
              "EMAIL_PASSWORD_PROVIDER"
              /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
            );
          case "emailLink":
            return signInWithEmailLinkForLinking2(auth2, {
              idToken,
              email: this._email,
              oobCode: this._password
            });
          default:
            _fail2(
              auth2,
              "internal-error"
              /* AuthErrorCode.INTERNAL_ERROR */
            );
        }
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        return this._getIdTokenResponse(auth2);
      }
    };
    async function signInWithIdp2(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithIdp", _addTidIfNecessary2(auth2, request));
    }
    var IDP_REQUEST_URI$12 = "http://localhost";
    var OAuthCredential2 = class _OAuthCredential extends AuthCredential2 {
      constructor() {
        super(...arguments);
        this.pendingToken = null;
      }
      /** @internal */
      static _fromParams(params) {
        const cred = new _OAuthCredential(params.providerId, params.signInMethod);
        if (params.idToken || params.accessToken) {
          if (params.idToken) {
            cred.idToken = params.idToken;
          }
          if (params.accessToken) {
            cred.accessToken = params.accessToken;
          }
          if (params.nonce && !params.pendingToken) {
            cred.nonce = params.nonce;
          }
          if (params.pendingToken) {
            cred.pendingToken = params.pendingToken;
          }
        } else if (params.oauthToken && params.oauthTokenSecret) {
          cred.accessToken = params.oauthToken;
          cred.secret = params.oauthTokenSecret;
        } else {
          _fail2(
            "argument-error"
            /* AuthErrorCode.ARGUMENT_ERROR */
          );
        }
        return cred;
      }
      /** {@inheritdoc AuthCredential.toJSON}  */
      toJSON() {
        return {
          idToken: this.idToken,
          accessToken: this.accessToken,
          secret: this.secret,
          nonce: this.nonce,
          pendingToken: this.pendingToken,
          providerId: this.providerId,
          signInMethod: this.signInMethod
        };
      }
      /**
       * Static method to deserialize a JSON representation of an object into an
       * {@link  AuthCredential}.
       *
       * @param json - Input can be either Object or the stringified representation of the object.
       * When string is provided, JSON.parse would be called first.
       *
       * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
       */
      static fromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        const { providerId, signInMethod, ...rest } = obj;
        if (!providerId || !signInMethod) {
          return null;
        }
        const cred = new _OAuthCredential(providerId, signInMethod);
        cred.idToken = rest.idToken || void 0;
        cred.accessToken = rest.accessToken || void 0;
        cred.secret = rest.secret;
        cred.nonce = rest.nonce;
        cred.pendingToken = rest.pendingToken || null;
        return cred;
      }
      /** @internal */
      _getIdTokenResponse(auth2) {
        const request = this.buildRequest();
        return signInWithIdp2(auth2, request);
      }
      /** @internal */
      _linkToIdToken(auth2, idToken) {
        const request = this.buildRequest();
        request.idToken = idToken;
        return signInWithIdp2(auth2, request);
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        const request = this.buildRequest();
        request.autoCreate = false;
        return signInWithIdp2(auth2, request);
      }
      buildRequest() {
        const request = {
          requestUri: IDP_REQUEST_URI$12,
          returnSecureToken: true
        };
        if (this.pendingToken) {
          request.pendingToken = this.pendingToken;
        } else {
          const postBody = {};
          if (this.idToken) {
            postBody["id_token"] = this.idToken;
          }
          if (this.accessToken) {
            postBody["access_token"] = this.accessToken;
          }
          if (this.secret) {
            postBody["oauth_token_secret"] = this.secret;
          }
          postBody["providerId"] = this.providerId;
          if (this.nonce && !this.pendingToken) {
            postBody["nonce"] = this.nonce;
          }
          request.postBody = util.querystring(postBody);
        }
        return request;
      }
    };
    async function signInWithPhoneNumber$12(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithPhoneNumber", _addTidIfNecessary2(auth2, request));
    }
    async function linkWithPhoneNumber$12(auth2, request) {
      const response = await _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithPhoneNumber", _addTidIfNecessary2(auth2, request));
      if (response.temporaryProof) {
        throw _makeTaggedError2(auth2, "account-exists-with-different-credential", response);
      }
      return response;
    }
    var VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_2 = {
      [
        "USER_NOT_FOUND"
        /* ServerError.USER_NOT_FOUND */
      ]: "user-not-found"
      /* AuthErrorCode.USER_DELETED */
    };
    async function verifyPhoneNumberForExisting2(auth2, request) {
      const apiRequest = {
        ...request,
        operation: "REAUTH"
      };
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithPhoneNumber", _addTidIfNecessary2(auth2, apiRequest), VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_2);
    }
    var PhoneAuthCredential2 = class _PhoneAuthCredential extends AuthCredential2 {
      constructor(params) {
        super(
          "phone",
          "phone"
          /* SignInMethod.PHONE */
        );
        this.params = params;
      }
      /** @internal */
      static _fromVerification(verificationId, verificationCode) {
        return new _PhoneAuthCredential({ verificationId, verificationCode });
      }
      /** @internal */
      static _fromTokenResponse(phoneNumber, temporaryProof) {
        return new _PhoneAuthCredential({ phoneNumber, temporaryProof });
      }
      /** @internal */
      _getIdTokenResponse(auth2) {
        return signInWithPhoneNumber$12(auth2, this._makeVerificationRequest());
      }
      /** @internal */
      _linkToIdToken(auth2, idToken) {
        return linkWithPhoneNumber$12(auth2, {
          idToken,
          ...this._makeVerificationRequest()
        });
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        return verifyPhoneNumberForExisting2(auth2, this._makeVerificationRequest());
      }
      /** @internal */
      _makeVerificationRequest() {
        const { temporaryProof, phoneNumber, verificationId, verificationCode } = this.params;
        if (temporaryProof && phoneNumber) {
          return { temporaryProof, phoneNumber };
        }
        return {
          sessionInfo: verificationId,
          code: verificationCode
        };
      }
      /** {@inheritdoc AuthCredential.toJSON} */
      toJSON() {
        const obj = {
          providerId: this.providerId
        };
        if (this.params.phoneNumber) {
          obj.phoneNumber = this.params.phoneNumber;
        }
        if (this.params.temporaryProof) {
          obj.temporaryProof = this.params.temporaryProof;
        }
        if (this.params.verificationCode) {
          obj.verificationCode = this.params.verificationCode;
        }
        if (this.params.verificationId) {
          obj.verificationId = this.params.verificationId;
        }
        return obj;
      }
      /** Generates a phone credential based on a plain object or a JSON string. */
      static fromJSON(json) {
        if (typeof json === "string") {
          json = JSON.parse(json);
        }
        const { verificationId, verificationCode, phoneNumber, temporaryProof } = json;
        if (!verificationCode && !verificationId && !phoneNumber && !temporaryProof) {
          return null;
        }
        return new _PhoneAuthCredential({
          verificationId,
          verificationCode,
          phoneNumber,
          temporaryProof
        });
      }
    };
    function parseMode2(mode) {
      switch (mode) {
        case "recoverEmail":
          return "RECOVER_EMAIL";
        case "resetPassword":
          return "PASSWORD_RESET";
        case "signIn":
          return "EMAIL_SIGNIN";
        case "verifyEmail":
          return "VERIFY_EMAIL";
        case "verifyAndChangeEmail":
          return "VERIFY_AND_CHANGE_EMAIL";
        case "revertSecondFactorAddition":
          return "REVERT_SECOND_FACTOR_ADDITION";
        default:
          return null;
      }
    }
    function parseDeepLink2(url) {
      const link = util.querystringDecode(util.extractQuerystring(url))["link"];
      const doubleDeepLink = link ? util.querystringDecode(util.extractQuerystring(link))["deep_link_id"] : null;
      const iOSDeepLink = util.querystringDecode(util.extractQuerystring(url))["deep_link_id"];
      const iOSDoubleDeepLink = iOSDeepLink ? util.querystringDecode(util.extractQuerystring(iOSDeepLink))["link"] : null;
      return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;
    }
    var ActionCodeURL2 = class _ActionCodeURL {
      /**
       * @param actionLink - The link from which to extract the URL.
       * @returns The {@link ActionCodeURL} object, or null if the link is invalid.
       *
       * @internal
       */
      constructor(actionLink) {
        const searchParams = util.querystringDecode(util.extractQuerystring(actionLink));
        const apiKey = searchParams[
          "apiKey"
          /* QueryField.API_KEY */
        ] ?? null;
        const code = searchParams[
          "oobCode"
          /* QueryField.CODE */
        ] ?? null;
        const operation = parseMode2(searchParams[
          "mode"
          /* QueryField.MODE */
        ] ?? null);
        _assert2(
          apiKey && code && operation,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        this.apiKey = apiKey;
        this.operation = operation;
        this.code = code;
        this.continueUrl = searchParams[
          "continueUrl"
          /* QueryField.CONTINUE_URL */
        ] ?? null;
        this.languageCode = searchParams[
          "lang"
          /* QueryField.LANGUAGE_CODE */
        ] ?? null;
        this.tenantId = searchParams[
          "tenantId"
          /* QueryField.TENANT_ID */
        ] ?? null;
      }
      /**
       * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,
       * otherwise returns null.
       *
       * @param link  - The email action link string.
       * @returns The {@link ActionCodeURL} object, or null if the link is invalid.
       *
       * @public
       */
      static parseLink(link) {
        const actionLink = parseDeepLink2(link);
        try {
          return new _ActionCodeURL(actionLink);
        } catch {
          return null;
        }
      }
    };
    function parseActionCodeURL2(link) {
      return ActionCodeURL2.parseLink(link);
    }
    var EmailAuthProvider2 = class _EmailAuthProvider {
      constructor() {
        this.providerId = _EmailAuthProvider.PROVIDER_ID;
      }
      /**
       * Initialize an {@link AuthCredential} using an email and password.
       *
       * @example
       * ```javascript
       * const authCredential = EmailAuthProvider.credential(email, password);
       * const userCredential = await signInWithCredential(auth, authCredential);
       * ```
       *
       * @example
       * ```javascript
       * const userCredential = await signInWithEmailAndPassword(auth, email, password);
       * ```
       *
       * @param email - Email address.
       * @param password - User account password.
       * @returns The auth provider credential.
       */
      static credential(email, password) {
        return EmailAuthCredential2._fromEmailAndPassword(email, password);
      }
      /**
       * Initialize an {@link AuthCredential} using an email and an email link after a sign in with
       * email link operation.
       *
       * @example
       * ```javascript
       * const authCredential = EmailAuthProvider.credentialWithLink(auth, email, emailLink);
       * const userCredential = await signInWithCredential(auth, authCredential);
       * ```
       *
       * @example
       * ```javascript
       * await sendSignInLinkToEmail(auth, email);
       * // Obtain emailLink from user.
       * const userCredential = await signInWithEmailLink(auth, email, emailLink);
       * ```
       *
       * @param auth - The {@link Auth} instance used to verify the link.
       * @param email - Email address.
       * @param emailLink - Sign-in email link.
       * @returns - The auth provider credential.
       */
      static credentialWithLink(email, emailLink) {
        const actionCodeUrl = ActionCodeURL2.parseLink(emailLink);
        _assert2(
          actionCodeUrl,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return EmailAuthCredential2._fromEmailAndCode(email, actionCodeUrl.code, actionCodeUrl.tenantId);
      }
    };
    EmailAuthProvider2.PROVIDER_ID = "password";
    EmailAuthProvider2.EMAIL_PASSWORD_SIGN_IN_METHOD = "password";
    EmailAuthProvider2.EMAIL_LINK_SIGN_IN_METHOD = "emailLink";
    var FederatedAuthProvider2 = class {
      /**
       * Constructor for generic OAuth providers.
       *
       * @param providerId - Provider for which credentials should be generated.
       */
      constructor(providerId) {
        this.providerId = providerId;
        this.defaultLanguageCode = null;
        this.customParameters = {};
      }
      /**
       * Set the language gode.
       *
       * @param languageCode - language code
       */
      setDefaultLanguage(languageCode) {
        this.defaultLanguageCode = languageCode;
      }
      /**
       * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in
       * operations.
       *
       * @remarks
       * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,
       * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.
       *
       * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.
       */
      setCustomParameters(customOAuthParameters) {
        this.customParameters = customOAuthParameters;
        return this;
      }
      /**
       * Retrieve the current list of {@link CustomParameters}.
       */
      getCustomParameters() {
        return this.customParameters;
      }
    };
    var BaseOAuthProvider2 = class extends FederatedAuthProvider2 {
      constructor() {
        super(...arguments);
        this.scopes = [];
      }
      /**
       * Add an OAuth scope to the credential.
       *
       * @param scope - Provider OAuth scope to add.
       */
      addScope(scope) {
        if (!this.scopes.includes(scope)) {
          this.scopes.push(scope);
        }
        return this;
      }
      /**
       * Retrieve the current list of OAuth scopes.
       */
      getScopes() {
        return [...this.scopes];
      }
    };
    var OAuthProvider2 = class _OAuthProvider extends BaseOAuthProvider2 {
      /**
       * Creates an {@link OAuthCredential} from a JSON string or a plain object.
       * @param json - A plain object or a JSON string
       */
      static credentialFromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        _assert2(
          "providerId" in obj && "signInMethod" in obj,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return OAuthCredential2._fromParams(obj);
      }
      /**
       * Creates a {@link OAuthCredential} from a generic OAuth provider's access token or ID token.
       *
       * @remarks
       * The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of
       * the raw nonce must match the nonce field in the ID token.
       *
       * @example
       * ```javascript
       * // `googleUser` from the onsuccess Google Sign In callback.
       * // Initialize a generate OAuth provider with a `google.com` providerId.
       * const provider = new OAuthProvider('google.com');
       * const credential = provider.credential({
       *   idToken: googleUser.getAuthResponse().id_token,
       * });
       * const result = await signInWithCredential(credential);
       * ```
       *
       * @param params - Either the options object containing the ID token, access token and raw nonce
       * or the ID token string.
       */
      credential(params) {
        return this._credential({ ...params, nonce: params.rawNonce });
      }
      /** An internal credential method that accepts more permissive options */
      _credential(params) {
        _assert2(
          params.idToken || params.accessToken,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return OAuthCredential2._fromParams({
          ...params,
          providerId: this.providerId,
          signInMethod: this.providerId
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _OAuthProvider.oauthCredentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _OAuthProvider.oauthCredentialFromTaggedObject(error.customData || {});
      }
      static oauthCredentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { oauthIdToken, oauthAccessToken, oauthTokenSecret, pendingToken, nonce, providerId } = tokenResponse;
        if (!oauthAccessToken && !oauthTokenSecret && !oauthIdToken && !pendingToken) {
          return null;
        }
        if (!providerId) {
          return null;
        }
        try {
          return new _OAuthProvider(providerId)._credential({
            idToken: oauthIdToken,
            accessToken: oauthAccessToken,
            nonce,
            pendingToken
          });
        } catch (e) {
          return null;
        }
      }
    };
    var FacebookAuthProvider2 = class _FacebookAuthProvider extends BaseOAuthProvider2 {
      constructor() {
        super(
          "facebook.com"
          /* ProviderId.FACEBOOK */
        );
      }
      /**
       * Creates a credential for Facebook.
       *
       * @example
       * ```javascript
       * // `event` from the Facebook auth.authResponseChange callback.
       * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);
       * const result = await signInWithCredential(credential);
       * ```
       *
       * @param accessToken - Facebook access token.
       */
      static credential(accessToken) {
        return OAuthCredential2._fromParams({
          providerId: _FacebookAuthProvider.PROVIDER_ID,
          signInMethod: _FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,
          accessToken
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _FacebookAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _FacebookAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
          return null;
        }
        if (!tokenResponse.oauthAccessToken) {
          return null;
        }
        try {
          return _FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);
        } catch {
          return null;
        }
      }
    };
    FacebookAuthProvider2.FACEBOOK_SIGN_IN_METHOD = "facebook.com";
    FacebookAuthProvider2.PROVIDER_ID = "facebook.com";
    var GoogleAuthProvider2 = class _GoogleAuthProvider extends BaseOAuthProvider2 {
      constructor() {
        super(
          "google.com"
          /* ProviderId.GOOGLE */
        );
        this.addScope("profile");
      }
      /**
       * Creates a credential for Google. At least one of ID token and access token is required.
       *
       * @example
       * ```javascript
       * // \`googleUser\` from the onsuccess Google Sign In callback.
       * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);
       * const result = await signInWithCredential(credential);
       * ```
       *
       * @param idToken - Google ID token.
       * @param accessToken - Google access token.
       */
      static credential(idToken, accessToken) {
        return OAuthCredential2._fromParams({
          providerId: _GoogleAuthProvider.PROVIDER_ID,
          signInMethod: _GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,
          idToken,
          accessToken
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _GoogleAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _GoogleAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { oauthIdToken, oauthAccessToken } = tokenResponse;
        if (!oauthIdToken && !oauthAccessToken) {
          return null;
        }
        try {
          return _GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);
        } catch {
          return null;
        }
      }
    };
    GoogleAuthProvider2.GOOGLE_SIGN_IN_METHOD = "google.com";
    GoogleAuthProvider2.PROVIDER_ID = "google.com";
    var GithubAuthProvider2 = class _GithubAuthProvider extends BaseOAuthProvider2 {
      constructor() {
        super(
          "github.com"
          /* ProviderId.GITHUB */
        );
      }
      /**
       * Creates a credential for GitHub.
       *
       * @param accessToken - GitHub access token.
       */
      static credential(accessToken) {
        return OAuthCredential2._fromParams({
          providerId: _GithubAuthProvider.PROVIDER_ID,
          signInMethod: _GithubAuthProvider.GITHUB_SIGN_IN_METHOD,
          accessToken
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _GithubAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _GithubAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse || !("oauthAccessToken" in tokenResponse)) {
          return null;
        }
        if (!tokenResponse.oauthAccessToken) {
          return null;
        }
        try {
          return _GithubAuthProvider.credential(tokenResponse.oauthAccessToken);
        } catch {
          return null;
        }
      }
    };
    GithubAuthProvider2.GITHUB_SIGN_IN_METHOD = "github.com";
    GithubAuthProvider2.PROVIDER_ID = "github.com";
    var IDP_REQUEST_URI2 = "http://localhost";
    var SAMLAuthCredential2 = class _SAMLAuthCredential extends AuthCredential2 {
      /** @internal */
      constructor(providerId, pendingToken) {
        super(providerId, providerId);
        this.pendingToken = pendingToken;
      }
      /** @internal */
      _getIdTokenResponse(auth2) {
        const request = this.buildRequest();
        return signInWithIdp2(auth2, request);
      }
      /** @internal */
      _linkToIdToken(auth2, idToken) {
        const request = this.buildRequest();
        request.idToken = idToken;
        return signInWithIdp2(auth2, request);
      }
      /** @internal */
      _getReauthenticationResolver(auth2) {
        const request = this.buildRequest();
        request.autoCreate = false;
        return signInWithIdp2(auth2, request);
      }
      /** {@inheritdoc AuthCredential.toJSON}  */
      toJSON() {
        return {
          signInMethod: this.signInMethod,
          providerId: this.providerId,
          pendingToken: this.pendingToken
        };
      }
      /**
       * Static method to deserialize a JSON representation of an object into an
       * {@link  AuthCredential}.
       *
       * @param json - Input can be either Object or the stringified representation of the object.
       * When string is provided, JSON.parse would be called first.
       *
       * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
       */
      static fromJSON(json) {
        const obj = typeof json === "string" ? JSON.parse(json) : json;
        const { providerId, signInMethod, pendingToken } = obj;
        if (!providerId || !signInMethod || !pendingToken || providerId !== signInMethod) {
          return null;
        }
        return new _SAMLAuthCredential(providerId, pendingToken);
      }
      /**
       * Helper static method to avoid exposing the constructor to end users.
       *
       * @internal
       */
      static _create(providerId, pendingToken) {
        return new _SAMLAuthCredential(providerId, pendingToken);
      }
      buildRequest() {
        return {
          requestUri: IDP_REQUEST_URI2,
          returnSecureToken: true,
          pendingToken: this.pendingToken
        };
      }
    };
    var SAML_PROVIDER_PREFIX2 = "saml.";
    var SAMLAuthProvider2 = class _SAMLAuthProvider extends FederatedAuthProvider2 {
      /**
       * Constructor. The providerId must start with "saml."
       * @param providerId - SAML provider ID.
       */
      constructor(providerId) {
        _assert2(
          providerId.startsWith(SAML_PROVIDER_PREFIX2),
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        super(providerId);
      }
      /**
       * Generates an {@link AuthCredential} from a {@link UserCredential} after a
       * successful SAML flow completes.
       *
       * @remarks
       *
       * For example, to get an {@link AuthCredential}, you could write the
       * following code:
       *
       * ```js
       * const userCredential = await signInWithPopup(auth, samlProvider);
       * const credential = SAMLAuthProvider.credentialFromResult(userCredential);
       * ```
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _SAMLAuthProvider.samlCredentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _SAMLAuthProvider.samlCredentialFromTaggedObject(error.customData || {});
      }
      /**
       * Creates an {@link AuthCredential} from a JSON string or a plain object.
       * @param json - A plain object or a JSON string
       */
      static credentialFromJSON(json) {
        const credential = SAMLAuthCredential2.fromJSON(json);
        _assert2(
          credential,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return credential;
      }
      static samlCredentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { pendingToken, providerId } = tokenResponse;
        if (!pendingToken || !providerId) {
          return null;
        }
        try {
          return SAMLAuthCredential2._create(providerId, pendingToken);
        } catch (e) {
          return null;
        }
      }
    };
    var TwitterAuthProvider2 = class _TwitterAuthProvider extends BaseOAuthProvider2 {
      constructor() {
        super(
          "twitter.com"
          /* ProviderId.TWITTER */
        );
      }
      /**
       * Creates a credential for Twitter.
       *
       * @param token - Twitter access token.
       * @param secret - Twitter secret.
       */
      static credential(token, secret) {
        return OAuthCredential2._fromParams({
          providerId: _TwitterAuthProvider.PROVIDER_ID,
          signInMethod: _TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,
          oauthToken: token,
          oauthTokenSecret: secret
        });
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromResult(userCredential) {
        return _TwitterAuthProvider.credentialFromTaggedObject(userCredential);
      }
      /**
       * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
       * thrown during a sign-in, link, or reauthenticate operation.
       *
       * @param userCredential - The user credential.
       */
      static credentialFromError(error) {
        return _TwitterAuthProvider.credentialFromTaggedObject(error.customData || {});
      }
      static credentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
        if (!tokenResponse) {
          return null;
        }
        const { oauthAccessToken, oauthTokenSecret } = tokenResponse;
        if (!oauthAccessToken || !oauthTokenSecret) {
          return null;
        }
        try {
          return _TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);
        } catch {
          return null;
        }
      }
    };
    TwitterAuthProvider2.TWITTER_SIGN_IN_METHOD = "twitter.com";
    TwitterAuthProvider2.PROVIDER_ID = "twitter.com";
    async function signUp2(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signUp", _addTidIfNecessary2(auth2, request));
    }
    var UserCredentialImpl2 = class _UserCredentialImpl {
      constructor(params) {
        this.user = params.user;
        this.providerId = params.providerId;
        this._tokenResponse = params._tokenResponse;
        this.operationType = params.operationType;
      }
      static async _fromIdTokenResponse(auth2, operationType, idTokenResponse, isAnonymous = false) {
        const user = await UserImpl2._fromIdTokenResponse(auth2, idTokenResponse, isAnonymous);
        const providerId = providerIdForResponse2(idTokenResponse);
        const userCred = new _UserCredentialImpl({
          user,
          providerId,
          _tokenResponse: idTokenResponse,
          operationType
        });
        return userCred;
      }
      static async _forOperation(user, operationType, response) {
        await user._updateTokensIfNecessary(
          response,
          /* reload */
          true
        );
        const providerId = providerIdForResponse2(response);
        return new _UserCredentialImpl({
          user,
          providerId,
          _tokenResponse: response,
          operationType
        });
      }
    };
    function providerIdForResponse2(response) {
      if (response.providerId) {
        return response.providerId;
      }
      if ("phoneNumber" in response) {
        return "phone";
      }
      return null;
    }
    async function signInAnonymously2(auth2) {
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      const authInternal = _castAuth2(auth2);
      await authInternal._initializationPromise;
      if (authInternal.currentUser?.isAnonymous) {
        return new UserCredentialImpl2({
          user: authInternal.currentUser,
          providerId: null,
          operationType: "signIn"
          /* OperationType.SIGN_IN */
        });
      }
      const response = await signUp2(authInternal, {
        returnSecureToken: true
      });
      const userCredential = await UserCredentialImpl2._fromIdTokenResponse(authInternal, "signIn", response, true);
      await authInternal._updateCurrentUser(userCredential.user);
      return userCredential;
    }
    var MultiFactorError2 = class _MultiFactorError extends util.FirebaseError {
      constructor(auth2, error, operationType, user) {
        super(error.code, error.message);
        this.operationType = operationType;
        this.user = user;
        Object.setPrototypeOf(this, _MultiFactorError.prototype);
        this.customData = {
          appName: auth2.name,
          tenantId: auth2.tenantId ?? void 0,
          _serverResponse: error.customData._serverResponse,
          operationType
        };
      }
      static _fromErrorAndOperation(auth2, error, operationType, user) {
        return new _MultiFactorError(auth2, error, operationType, user);
      }
    };
    function _processCredentialSavingMfaContextIfNecessary2(auth2, operationType, credential, user) {
      const idTokenProvider = operationType === "reauthenticate" ? credential._getReauthenticationResolver(auth2) : credential._getIdTokenResponse(auth2);
      return idTokenProvider.catch((error) => {
        if (error.code === `auth/${"multi-factor-auth-required"}`) {
          throw MultiFactorError2._fromErrorAndOperation(auth2, error, operationType, user);
        }
        throw error;
      });
    }
    function providerDataAsNames2(providerData) {
      return new Set(providerData.map(({ providerId }) => providerId).filter((pid) => !!pid));
    }
    async function unlink2(user, providerId) {
      const userInternal = util.getModularInstance(user);
      await _assertLinkedStatus2(true, userInternal, providerId);
      const { providerUserInfo } = await deleteLinkedAccounts2(userInternal.auth, {
        idToken: await userInternal.getIdToken(),
        deleteProvider: [providerId]
      });
      const providersLeft = providerDataAsNames2(providerUserInfo || []);
      userInternal.providerData = userInternal.providerData.filter((pd) => providersLeft.has(pd.providerId));
      if (!providersLeft.has(
        "phone"
        /* ProviderId.PHONE */
      )) {
        userInternal.phoneNumber = null;
      }
      await userInternal.auth._persistUserIfCurrent(userInternal);
      return userInternal;
    }
    async function _link2(user, credential, bypassAuthState = false) {
      const response = await _logoutIfInvalidated2(user, credential._linkToIdToken(user.auth, await user.getIdToken()), bypassAuthState);
      return UserCredentialImpl2._forOperation(user, "link", response);
    }
    async function _assertLinkedStatus2(expected, user, provider) {
      await _reloadWithoutSaving2(user);
      const providerIds = providerDataAsNames2(user.providerData);
      const code = expected === false ? "provider-already-linked" : "no-such-provider";
      _assert2(providerIds.has(provider) === expected, user.auth, code);
    }
    async function _reauthenticate2(user, credential, bypassAuthState = false) {
      const { auth: auth2 } = user;
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      const operationType = "reauthenticate";
      try {
        const response = await _logoutIfInvalidated2(user, _processCredentialSavingMfaContextIfNecessary2(auth2, operationType, credential, user), bypassAuthState);
        _assert2(
          response.idToken,
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const parsed = _parseToken2(response.idToken);
        _assert2(
          parsed,
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const { sub: localId } = parsed;
        _assert2(
          user.uid === localId,
          auth2,
          "user-mismatch"
          /* AuthErrorCode.USER_MISMATCH */
        );
        return UserCredentialImpl2._forOperation(user, operationType, response);
      } catch (e) {
        if (e?.code === `auth/${"user-not-found"}`) {
          _fail2(
            auth2,
            "user-mismatch"
            /* AuthErrorCode.USER_MISMATCH */
          );
        }
        throw e;
      }
    }
    async function _signInWithCredential2(auth2, credential, bypassAuthState = false) {
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      const operationType = "signIn";
      const response = await _processCredentialSavingMfaContextIfNecessary2(auth2, operationType, credential);
      const userCredential = await UserCredentialImpl2._fromIdTokenResponse(auth2, operationType, response);
      if (!bypassAuthState) {
        await auth2._updateCurrentUser(userCredential.user);
      }
      return userCredential;
    }
    async function signInWithCredential2(auth2, credential) {
      return _signInWithCredential2(_castAuth2(auth2), credential);
    }
    async function linkWithCredential2(user, credential) {
      const userInternal = util.getModularInstance(user);
      await _assertLinkedStatus2(false, userInternal, credential.providerId);
      return _link2(userInternal, credential);
    }
    async function reauthenticateWithCredential2(user, credential) {
      return _reauthenticate2(util.getModularInstance(user), credential);
    }
    async function signInWithCustomToken$12(auth2, request) {
      return _performSignInRequest2(auth2, "POST", "/v1/accounts:signInWithCustomToken", _addTidIfNecessary2(auth2, request));
    }
    async function signInWithCustomToken2(auth2, customToken) {
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      const authInternal = _castAuth2(auth2);
      const response = await signInWithCustomToken$12(authInternal, {
        token: customToken,
        returnSecureToken: true
      });
      const cred = await UserCredentialImpl2._fromIdTokenResponse(authInternal, "signIn", response);
      await authInternal._updateCurrentUser(cred.user);
      return cred;
    }
    var MultiFactorInfoImpl2 = class {
      constructor(factorId, response) {
        this.factorId = factorId;
        this.uid = response.mfaEnrollmentId;
        this.enrollmentTime = new Date(response.enrolledAt).toUTCString();
        this.displayName = response.displayName;
      }
      static _fromServerResponse(auth2, enrollment) {
        if ("phoneInfo" in enrollment) {
          return PhoneMultiFactorInfoImpl2._fromServerResponse(auth2, enrollment);
        } else if ("totpInfo" in enrollment) {
          return TotpMultiFactorInfoImpl2._fromServerResponse(auth2, enrollment);
        }
        return _fail2(
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
      }
    };
    var PhoneMultiFactorInfoImpl2 = class _PhoneMultiFactorInfoImpl extends MultiFactorInfoImpl2 {
      constructor(response) {
        super("phone", response);
        this.phoneNumber = response.phoneInfo;
      }
      static _fromServerResponse(_auth, enrollment) {
        return new _PhoneMultiFactorInfoImpl(enrollment);
      }
    };
    var TotpMultiFactorInfoImpl2 = class _TotpMultiFactorInfoImpl extends MultiFactorInfoImpl2 {
      constructor(response) {
        super("totp", response);
      }
      static _fromServerResponse(_auth, enrollment) {
        return new _TotpMultiFactorInfoImpl(enrollment);
      }
    };
    function _setActionCodeSettingsOnRequest2(auth2, request, actionCodeSettings) {
      _assert2(
        actionCodeSettings.url?.length > 0,
        auth2,
        "invalid-continue-uri"
        /* AuthErrorCode.INVALID_CONTINUE_URI */
      );
      _assert2(
        typeof actionCodeSettings.dynamicLinkDomain === "undefined" || actionCodeSettings.dynamicLinkDomain.length > 0,
        auth2,
        "invalid-dynamic-link-domain"
        /* AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN */
      );
      _assert2(
        typeof actionCodeSettings.linkDomain === "undefined" || actionCodeSettings.linkDomain.length > 0,
        auth2,
        "invalid-hosting-link-domain"
        /* AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN */
      );
      request.continueUrl = actionCodeSettings.url;
      request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;
      request.linkDomain = actionCodeSettings.linkDomain;
      request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;
      if (actionCodeSettings.iOS) {
        _assert2(
          actionCodeSettings.iOS.bundleId.length > 0,
          auth2,
          "missing-ios-bundle-id"
          /* AuthErrorCode.MISSING_IOS_BUNDLE_ID */
        );
        request.iOSBundleId = actionCodeSettings.iOS.bundleId;
      }
      if (actionCodeSettings.android) {
        _assert2(
          actionCodeSettings.android.packageName.length > 0,
          auth2,
          "missing-android-pkg-name"
          /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */
        );
        request.androidInstallApp = actionCodeSettings.android.installApp;
        request.androidMinimumVersionCode = actionCodeSettings.android.minimumVersion;
        request.androidPackageName = actionCodeSettings.android.packageName;
      }
    }
    async function recachePasswordPolicy2(auth2) {
      const authInternal = _castAuth2(auth2);
      if (authInternal._getPasswordPolicyInternal()) {
        await authInternal._updatePasswordPolicy();
      }
    }
    async function sendPasswordResetEmail2(auth2, email, actionCodeSettings) {
      const authInternal = _castAuth2(auth2);
      const request = {
        requestType: "PASSWORD_RESET",
        email,
        clientType: "CLIENT_TYPE_WEB"
        /* RecaptchaClientType.WEB */
      };
      if (actionCodeSettings) {
        _setActionCodeSettingsOnRequest2(authInternal, request, actionCodeSettings);
      }
      await handleRecaptchaFlow2(
        authInternal,
        request,
        "getOobCode",
        sendPasswordResetEmail$12,
        "EMAIL_PASSWORD_PROVIDER"
        /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
      );
    }
    async function confirmPasswordReset2(auth2, oobCode, newPassword) {
      await resetPassword2(util.getModularInstance(auth2), {
        oobCode,
        newPassword
      }).catch(async (error) => {
        if (error.code === `auth/${"password-does-not-meet-requirements"}`) {
          void recachePasswordPolicy2(auth2);
        }
        throw error;
      });
    }
    async function applyActionCode2(auth2, oobCode) {
      await applyActionCode$12(util.getModularInstance(auth2), { oobCode });
    }
    async function checkActionCode2(auth2, oobCode) {
      const authModular = util.getModularInstance(auth2);
      const response = await resetPassword2(authModular, { oobCode });
      const operation = response.requestType;
      _assert2(
        operation,
        authModular,
        "internal-error"
        /* AuthErrorCode.INTERNAL_ERROR */
      );
      switch (operation) {
        case "EMAIL_SIGNIN":
          break;
        case "VERIFY_AND_CHANGE_EMAIL":
          _assert2(
            response.newEmail,
            authModular,
            "internal-error"
            /* AuthErrorCode.INTERNAL_ERROR */
          );
          break;
        case "REVERT_SECOND_FACTOR_ADDITION":
          _assert2(
            response.mfaInfo,
            authModular,
            "internal-error"
            /* AuthErrorCode.INTERNAL_ERROR */
          );
        // fall through
        default:
          _assert2(
            response.email,
            authModular,
            "internal-error"
            /* AuthErrorCode.INTERNAL_ERROR */
          );
      }
      let multiFactorInfo = null;
      if (response.mfaInfo) {
        multiFactorInfo = MultiFactorInfoImpl2._fromServerResponse(_castAuth2(authModular), response.mfaInfo);
      }
      return {
        data: {
          email: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" ? response.newEmail : response.email) || null,
          previousEmail: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" ? response.email : response.newEmail) || null,
          multiFactorInfo
        },
        operation
      };
    }
    async function verifyPasswordResetCode2(auth2, code) {
      const { data } = await checkActionCode2(util.getModularInstance(auth2), code);
      return data.email;
    }
    async function createUserWithEmailAndPassword2(auth2, email, password) {
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      const authInternal = _castAuth2(auth2);
      const request = {
        returnSecureToken: true,
        email,
        password,
        clientType: "CLIENT_TYPE_WEB"
        /* RecaptchaClientType.WEB */
      };
      const signUpResponse = handleRecaptchaFlow2(
        authInternal,
        request,
        "signUpPassword",
        signUp2,
        "EMAIL_PASSWORD_PROVIDER"
        /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
      );
      const response = await signUpResponse.catch((error) => {
        if (error.code === `auth/${"password-does-not-meet-requirements"}`) {
          void recachePasswordPolicy2(auth2);
        }
        throw error;
      });
      const userCredential = await UserCredentialImpl2._fromIdTokenResponse(authInternal, "signIn", response);
      await authInternal._updateCurrentUser(userCredential.user);
      return userCredential;
    }
    function signInWithEmailAndPassword2(auth2, email, password) {
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      return signInWithCredential2(util.getModularInstance(auth2), EmailAuthProvider2.credential(email, password)).catch(async (error) => {
        if (error.code === `auth/${"password-does-not-meet-requirements"}`) {
          void recachePasswordPolicy2(auth2);
        }
        throw error;
      });
    }
    async function sendSignInLinkToEmail2(auth2, email, actionCodeSettings) {
      const authInternal = _castAuth2(auth2);
      const request = {
        requestType: "EMAIL_SIGNIN",
        email,
        clientType: "CLIENT_TYPE_WEB"
        /* RecaptchaClientType.WEB */
      };
      function setActionCodeSettings(request2, actionCodeSettings2) {
        _assert2(
          actionCodeSettings2.handleCodeInApp,
          authInternal,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        if (actionCodeSettings2) {
          _setActionCodeSettingsOnRequest2(authInternal, request2, actionCodeSettings2);
        }
      }
      setActionCodeSettings(request, actionCodeSettings);
      await handleRecaptchaFlow2(
        authInternal,
        request,
        "getOobCode",
        sendSignInLinkToEmail$12,
        "EMAIL_PASSWORD_PROVIDER"
        /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */
      );
    }
    function isSignInWithEmailLink2(auth2, emailLink) {
      const actionCodeUrl = ActionCodeURL2.parseLink(emailLink);
      return actionCodeUrl?.operation === "EMAIL_SIGNIN";
    }
    async function signInWithEmailLink2(auth2, email, emailLink) {
      if (app2._isFirebaseServerApp(auth2.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(auth2));
      }
      const authModular = util.getModularInstance(auth2);
      const credential = EmailAuthProvider2.credentialWithLink(email, emailLink || _getCurrentUrl2());
      _assert2(
        credential._tenantId === (authModular.tenantId || null),
        authModular,
        "tenant-id-mismatch"
        /* AuthErrorCode.TENANT_ID_MISMATCH */
      );
      return signInWithCredential2(authModular, credential);
    }
    async function createAuthUri2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:createAuthUri", _addTidIfNecessary2(auth2, request));
    }
    async function fetchSignInMethodsForEmail2(auth2, email) {
      const continueUri = _isHttpOrHttps2() ? _getCurrentUrl2() : "http://localhost";
      const request = {
        identifier: email,
        continueUri
      };
      const { signinMethods } = await createAuthUri2(util.getModularInstance(auth2), request);
      return signinMethods || [];
    }
    async function sendEmailVerification2(user, actionCodeSettings) {
      const userInternal = util.getModularInstance(user);
      const idToken = await user.getIdToken();
      const request = {
        requestType: "VERIFY_EMAIL",
        idToken
      };
      if (actionCodeSettings) {
        _setActionCodeSettingsOnRequest2(userInternal.auth, request, actionCodeSettings);
      }
      const { email } = await sendEmailVerification$12(userInternal.auth, request);
      if (email !== user.email) {
        await user.reload();
      }
    }
    async function verifyBeforeUpdateEmail2(user, newEmail, actionCodeSettings) {
      const userInternal = util.getModularInstance(user);
      const idToken = await user.getIdToken();
      const request = {
        requestType: "VERIFY_AND_CHANGE_EMAIL",
        idToken,
        newEmail
      };
      if (actionCodeSettings) {
        _setActionCodeSettingsOnRequest2(userInternal.auth, request, actionCodeSettings);
      }
      const { email } = await verifyAndChangeEmail2(userInternal.auth, request);
      if (email !== user.email) {
        await user.reload();
      }
    }
    async function updateProfile$12(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v1/accounts:update", request);
    }
    async function updateProfile2(user, { displayName, photoURL: photoUrl }) {
      if (displayName === void 0 && photoUrl === void 0) {
        return;
      }
      const userInternal = util.getModularInstance(user);
      const idToken = await userInternal.getIdToken();
      const profileRequest = {
        idToken,
        displayName,
        photoUrl,
        returnSecureToken: true
      };
      const response = await _logoutIfInvalidated2(userInternal, updateProfile$12(userInternal.auth, profileRequest));
      userInternal.displayName = response.displayName || null;
      userInternal.photoURL = response.photoUrl || null;
      const passwordProvider = userInternal.providerData.find(
        ({ providerId }) => providerId === "password"
        /* ProviderId.PASSWORD */
      );
      if (passwordProvider) {
        passwordProvider.displayName = userInternal.displayName;
        passwordProvider.photoURL = userInternal.photoURL;
      }
      await userInternal._updateTokensIfNecessary(response);
    }
    function updateEmail2(user, newEmail) {
      const userInternal = util.getModularInstance(user);
      if (app2._isFirebaseServerApp(userInternal.auth.app)) {
        return Promise.reject(_serverAppCurrentUserOperationNotSupportedError2(userInternal.auth));
      }
      return updateEmailOrPassword2(userInternal, newEmail, null);
    }
    function updatePassword2(user, newPassword) {
      return updateEmailOrPassword2(util.getModularInstance(user), null, newPassword);
    }
    async function updateEmailOrPassword2(user, email, password) {
      const { auth: auth2 } = user;
      const idToken = await user.getIdToken();
      const request = {
        idToken,
        returnSecureToken: true
      };
      if (email) {
        request.email = email;
      }
      if (password) {
        request.password = password;
      }
      const response = await _logoutIfInvalidated2(user, updateEmailPassword2(auth2, request));
      await user._updateTokensIfNecessary(
        response,
        /* reload */
        true
      );
    }
    function _fromIdTokenResponse2(idTokenResponse) {
      if (!idTokenResponse) {
        return null;
      }
      const { providerId } = idTokenResponse;
      const profile = idTokenResponse.rawUserInfo ? JSON.parse(idTokenResponse.rawUserInfo) : {};
      const isNewUser = idTokenResponse.isNewUser || idTokenResponse.kind === "identitytoolkit#SignupNewUserResponse";
      if (!providerId && idTokenResponse?.idToken) {
        const signInProvider = _parseToken2(idTokenResponse.idToken)?.firebase?.["sign_in_provider"];
        if (signInProvider) {
          const filteredProviderId = signInProvider !== "anonymous" && signInProvider !== "custom" ? signInProvider : null;
          return new GenericAdditionalUserInfo2(isNewUser, filteredProviderId);
        }
      }
      if (!providerId) {
        return null;
      }
      switch (providerId) {
        case "facebook.com":
          return new FacebookAdditionalUserInfo2(isNewUser, profile);
        case "github.com":
          return new GithubAdditionalUserInfo2(isNewUser, profile);
        case "google.com":
          return new GoogleAdditionalUserInfo2(isNewUser, profile);
        case "twitter.com":
          return new TwitterAdditionalUserInfo2(isNewUser, profile, idTokenResponse.screenName || null);
        case "custom":
        case "anonymous":
          return new GenericAdditionalUserInfo2(isNewUser, null);
        default:
          return new GenericAdditionalUserInfo2(isNewUser, providerId, profile);
      }
    }
    var GenericAdditionalUserInfo2 = class {
      constructor(isNewUser, providerId, profile = {}) {
        this.isNewUser = isNewUser;
        this.providerId = providerId;
        this.profile = profile;
      }
    };
    var FederatedAdditionalUserInfoWithUsername2 = class extends GenericAdditionalUserInfo2 {
      constructor(isNewUser, providerId, profile, username) {
        super(isNewUser, providerId, profile);
        this.username = username;
      }
    };
    var FacebookAdditionalUserInfo2 = class extends GenericAdditionalUserInfo2 {
      constructor(isNewUser, profile) {
        super(isNewUser, "facebook.com", profile);
      }
    };
    var GithubAdditionalUserInfo2 = class extends FederatedAdditionalUserInfoWithUsername2 {
      constructor(isNewUser, profile) {
        super(isNewUser, "github.com", profile, typeof profile?.login === "string" ? profile?.login : null);
      }
    };
    var GoogleAdditionalUserInfo2 = class extends GenericAdditionalUserInfo2 {
      constructor(isNewUser, profile) {
        super(isNewUser, "google.com", profile);
      }
    };
    var TwitterAdditionalUserInfo2 = class extends FederatedAdditionalUserInfoWithUsername2 {
      constructor(isNewUser, profile, screenName) {
        super(isNewUser, "twitter.com", profile, screenName);
      }
    };
    function getAdditionalUserInfo2(userCredential) {
      const { user, _tokenResponse } = userCredential;
      if (user.isAnonymous && !_tokenResponse) {
        return {
          providerId: null,
          isNewUser: false,
          profile: null
        };
      }
      return _fromIdTokenResponse2(_tokenResponse);
    }
    function setPersistence2(auth2, persistence) {
      return util.getModularInstance(auth2).setPersistence(persistence);
    }
    function initializeRecaptchaConfig2(auth2) {
      return _initializeRecaptchaConfig2(auth2);
    }
    async function validatePassword2(auth2, password) {
      const authInternal = _castAuth2(auth2);
      return authInternal.validatePassword(password);
    }
    function onIdTokenChanged2(auth2, nextOrObserver, error, completed) {
      return util.getModularInstance(auth2).onIdTokenChanged(nextOrObserver, error, completed);
    }
    function beforeAuthStateChanged2(auth2, callback, onAbort) {
      return util.getModularInstance(auth2).beforeAuthStateChanged(callback, onAbort);
    }
    function onAuthStateChanged2(auth2, nextOrObserver, error, completed) {
      return util.getModularInstance(auth2).onAuthStateChanged(nextOrObserver, error, completed);
    }
    function useDeviceLanguage2(auth2) {
      util.getModularInstance(auth2).useDeviceLanguage();
    }
    function updateCurrentUser2(auth2, user) {
      return util.getModularInstance(auth2).updateCurrentUser(user);
    }
    function signOut2(auth2) {
      return util.getModularInstance(auth2).signOut();
    }
    function revokeAccessToken2(auth2, token) {
      const authInternal = _castAuth2(auth2);
      return authInternal.revokeAccessToken(token);
    }
    async function deleteUser2(user) {
      return util.getModularInstance(user).delete();
    }
    var MultiFactorSessionImpl2 = class _MultiFactorSessionImpl {
      constructor(type, credential, user) {
        this.type = type;
        this.credential = credential;
        this.user = user;
      }
      static _fromIdtoken(idToken, user) {
        return new _MultiFactorSessionImpl("enroll", idToken, user);
      }
      static _fromMfaPendingCredential(mfaPendingCredential) {
        return new _MultiFactorSessionImpl("signin", mfaPendingCredential);
      }
      toJSON() {
        const key = this.type === "enroll" ? "idToken" : "pendingCredential";
        return {
          multiFactorSession: {
            [key]: this.credential
          }
        };
      }
      static fromJSON(obj) {
        if (obj?.multiFactorSession) {
          if (obj.multiFactorSession?.pendingCredential) {
            return _MultiFactorSessionImpl._fromMfaPendingCredential(obj.multiFactorSession.pendingCredential);
          } else if (obj.multiFactorSession?.idToken) {
            return _MultiFactorSessionImpl._fromIdtoken(obj.multiFactorSession.idToken);
          }
        }
        return null;
      }
    };
    var MultiFactorResolverImpl2 = class _MultiFactorResolverImpl {
      constructor(session, hints, signInResolver) {
        this.session = session;
        this.hints = hints;
        this.signInResolver = signInResolver;
      }
      /** @internal */
      static _fromError(authExtern, error) {
        const auth2 = _castAuth2(authExtern);
        const serverResponse = error.customData._serverResponse;
        const hints = (serverResponse.mfaInfo || []).map((enrollment) => MultiFactorInfoImpl2._fromServerResponse(auth2, enrollment));
        _assert2(
          serverResponse.mfaPendingCredential,
          auth2,
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const session = MultiFactorSessionImpl2._fromMfaPendingCredential(serverResponse.mfaPendingCredential);
        return new _MultiFactorResolverImpl(session, hints, async (assertion) => {
          const mfaResponse = await assertion._process(auth2, session);
          delete serverResponse.mfaInfo;
          delete serverResponse.mfaPendingCredential;
          const idTokenResponse = {
            ...serverResponse,
            idToken: mfaResponse.idToken,
            refreshToken: mfaResponse.refreshToken
          };
          switch (error.operationType) {
            case "signIn":
              const userCredential = await UserCredentialImpl2._fromIdTokenResponse(auth2, error.operationType, idTokenResponse);
              await auth2._updateCurrentUser(userCredential.user);
              return userCredential;
            case "reauthenticate":
              _assert2(
                error.user,
                auth2,
                "internal-error"
                /* AuthErrorCode.INTERNAL_ERROR */
              );
              return UserCredentialImpl2._forOperation(error.user, error.operationType, idTokenResponse);
            default:
              _fail2(
                auth2,
                "internal-error"
                /* AuthErrorCode.INTERNAL_ERROR */
              );
          }
        });
      }
      async resolveSignIn(assertionExtern) {
        const assertion = assertionExtern;
        return this.signInResolver(assertion);
      }
    };
    function getMultiFactorResolver2(auth2, error) {
      const authModular = util.getModularInstance(auth2);
      const errorInternal = error;
      _assert2(
        error.customData.operationType,
        authModular,
        "argument-error"
        /* AuthErrorCode.ARGUMENT_ERROR */
      );
      _assert2(
        errorInternal.customData._serverResponse?.mfaPendingCredential,
        authModular,
        "argument-error"
        /* AuthErrorCode.ARGUMENT_ERROR */
      );
      return MultiFactorResolverImpl2._fromError(authModular, errorInternal);
    }
    function startEnrollTotpMfa2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v2/accounts/mfaEnrollment:start", _addTidIfNecessary2(auth2, request));
    }
    function finalizeEnrollTotpMfa2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v2/accounts/mfaEnrollment:finalize", _addTidIfNecessary2(auth2, request));
    }
    function withdrawMfa2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v2/accounts/mfaEnrollment:withdraw", _addTidIfNecessary2(auth2, request));
    }
    var MultiFactorUserImpl2 = class _MultiFactorUserImpl {
      constructor(user) {
        this.user = user;
        this.enrolledFactors = [];
        user._onReload((userInfo) => {
          if (userInfo.mfaInfo) {
            this.enrolledFactors = userInfo.mfaInfo.map((enrollment) => MultiFactorInfoImpl2._fromServerResponse(user.auth, enrollment));
          }
        });
      }
      static _fromUser(user) {
        return new _MultiFactorUserImpl(user);
      }
      async getSession() {
        return MultiFactorSessionImpl2._fromIdtoken(await this.user.getIdToken(), this.user);
      }
      async enroll(assertionExtern, displayName) {
        const assertion = assertionExtern;
        const session = await this.getSession();
        const finalizeMfaResponse = await _logoutIfInvalidated2(this.user, assertion._process(this.user.auth, session, displayName));
        await this.user._updateTokensIfNecessary(finalizeMfaResponse);
        return this.user.reload();
      }
      async unenroll(infoOrUid) {
        const mfaEnrollmentId = typeof infoOrUid === "string" ? infoOrUid : infoOrUid.uid;
        const idToken = await this.user.getIdToken();
        try {
          const idTokenResponse = await _logoutIfInvalidated2(this.user, withdrawMfa2(this.user.auth, {
            idToken,
            mfaEnrollmentId
          }));
          this.enrolledFactors = this.enrolledFactors.filter(({ uid }) => uid !== mfaEnrollmentId);
          await this.user._updateTokensIfNecessary(idTokenResponse);
          await this.user.reload();
        } catch (e) {
          throw e;
        }
      }
    };
    var multiFactorUserCache2 = /* @__PURE__ */ new WeakMap();
    function multiFactor2(user) {
      const userModular = util.getModularInstance(user);
      if (!multiFactorUserCache2.has(userModular)) {
        multiFactorUserCache2.set(userModular, MultiFactorUserImpl2._fromUser(userModular));
      }
      return multiFactorUserCache2.get(userModular);
    }
    var name6 = "@firebase/auth";
    var version6 = "1.11.1";
    var AuthInterop2 = class {
      constructor(auth2) {
        this.auth = auth2;
        this.internalListeners = /* @__PURE__ */ new Map();
      }
      getUid() {
        this.assertAuthConfigured();
        return this.auth.currentUser?.uid || null;
      }
      async getToken(forceRefresh) {
        this.assertAuthConfigured();
        await this.auth._initializationPromise;
        if (!this.auth.currentUser) {
          return null;
        }
        const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);
        return { accessToken };
      }
      addAuthTokenListener(listener) {
        this.assertAuthConfigured();
        if (this.internalListeners.has(listener)) {
          return;
        }
        const unsubscribe = this.auth.onIdTokenChanged((user) => {
          listener(user?.stsTokenManager.accessToken || null);
        });
        this.internalListeners.set(listener, unsubscribe);
        this.updateProactiveRefresh();
      }
      removeAuthTokenListener(listener) {
        this.assertAuthConfigured();
        const unsubscribe = this.internalListeners.get(listener);
        if (!unsubscribe) {
          return;
        }
        this.internalListeners.delete(listener);
        unsubscribe();
        this.updateProactiveRefresh();
      }
      assertAuthConfigured() {
        _assert2(
          this.auth._initializationPromise,
          "dependent-sdk-initialized-before-auth"
          /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
        );
      }
      updateProactiveRefresh() {
        if (this.internalListeners.size > 0) {
          this.auth._startProactiveRefresh();
        } else {
          this.auth._stopProactiveRefresh();
        }
      }
    };
    function getVersionForPlatform2(clientPlatform) {
      switch (clientPlatform) {
        case "Node":
          return "node";
        case "ReactNative":
          return "rn";
        case "Worker":
          return "webworker";
        case "Cordova":
          return "cordova";
        case "WebExtension":
          return "web-extension";
        default:
          return void 0;
      }
    }
    function registerAuth2(clientPlatform) {
      app2._registerComponent(new component.Component(
        "auth",
        (container, { options: deps }) => {
          const app3 = container.getProvider("app").getImmediate();
          const heartbeatServiceProvider = container.getProvider("heartbeat");
          const appCheckServiceProvider = container.getProvider("app-check-internal");
          const { apiKey, authDomain } = app3.options;
          _assert2(apiKey && !apiKey.includes(":"), "invalid-api-key", { appName: app3.name });
          const config = {
            apiKey,
            authDomain,
            clientPlatform,
            apiHost: "identitytoolkit.googleapis.com",
            tokenApiHost: "securetoken.googleapis.com",
            apiScheme: "https",
            sdkClientVersion: _getClientVersion2(clientPlatform)
          };
          const authInstance = new AuthImpl2(app3, heartbeatServiceProvider, appCheckServiceProvider, config);
          _initializeAuthInstance2(authInstance, deps);
          return authInstance;
        },
        "PUBLIC"
        /* ComponentType.PUBLIC */
      ).setInstantiationMode(
        "EXPLICIT"
        /* InstantiationMode.EXPLICIT */
      ).setInstanceCreatedCallback((container, _instanceIdentifier, _instance) => {
        const authInternalProvider = container.getProvider(
          "auth-internal"
          /* _ComponentName.AUTH_INTERNAL */
        );
        authInternalProvider.initialize();
      }));
      app2._registerComponent(new component.Component(
        "auth-internal",
        (container) => {
          const auth2 = _castAuth2(container.getProvider(
            "auth"
            /* _ComponentName.AUTH */
          ).getImmediate());
          return ((auth3) => new AuthInterop2(auth3))(auth2);
        },
        "PRIVATE"
        /* ComponentType.PRIVATE */
      ).setInstantiationMode(
        "EXPLICIT"
        /* InstantiationMode.EXPLICIT */
      ));
      app2.registerVersion(name6, version6, getVersionForPlatform2(clientPlatform));
      app2.registerVersion(name6, version6, "cjs2020");
    }
    FetchProvider2.initialize(fetch, Headers, Response);
    function getAuth2(app$1 = app2.getApp()) {
      const provider = app2._getProvider(app$1, "auth");
      if (provider.isInitialized()) {
        return provider.getImmediate();
      }
      const auth2 = initializeAuth2(app$1);
      const authEmulatorHost = util.getDefaultEmulatorHost("auth");
      if (authEmulatorHost) {
        connectAuthEmulator2(auth2, `http://${authEmulatorHost}`);
      }
      return auth2;
    }
    registerAuth2(
      "Node"
      /* ClientPlatform.NODE */
    );
    var NOT_AVAILABLE_ERROR2 = _createError2(
      "operation-not-supported-in-this-environment"
      /* AuthErrorCode.OPERATION_NOT_SUPPORTED */
    );
    async function fail2() {
      throw NOT_AVAILABLE_ERROR2;
    }
    var FailClass2 = class {
      constructor() {
        throw NOT_AVAILABLE_ERROR2;
      }
    };
    var browserLocalPersistence2 = inMemoryPersistence2;
    var browserSessionPersistence2 = inMemoryPersistence2;
    var browserCookiePersistence2 = inMemoryPersistence2;
    var indexedDBLocalPersistence2 = inMemoryPersistence2;
    var browserPopupRedirectResolver2 = NOT_AVAILABLE_ERROR2;
    var PhoneAuthProvider2 = FailClass2;
    var signInWithPhoneNumber2 = fail2;
    var linkWithPhoneNumber2 = fail2;
    var reauthenticateWithPhoneNumber2 = fail2;
    var updatePhoneNumber2 = fail2;
    var signInWithPopup2 = fail2;
    var linkWithPopup2 = fail2;
    var reauthenticateWithPopup2 = fail2;
    var signInWithRedirect2 = fail2;
    var linkWithRedirect2 = fail2;
    var reauthenticateWithRedirect2 = fail2;
    var getRedirectResult2 = fail2;
    var RecaptchaVerifier2 = FailClass2;
    var PhoneMultiFactorGenerator2 = class {
      static assertion() {
        throw NOT_AVAILABLE_ERROR2;
      }
    };
    AuthImpl2.prototype.setPersistence = async () => {
    };
    function finalizeSignInTotpMfa2(auth2, request) {
      return _performApiRequest2(auth2, "POST", "/v2/accounts/mfaSignIn:finalize", _addTidIfNecessary2(auth2, request));
    }
    var MultiFactorAssertionImpl2 = class {
      constructor(factorId) {
        this.factorId = factorId;
      }
      _process(auth2, session, displayName) {
        switch (session.type) {
          case "enroll":
            return this._finalizeEnroll(auth2, session.credential, displayName);
          case "signin":
            return this._finalizeSignIn(auth2, session.credential);
          default:
            return debugFail2("unexpected MultiFactorSessionType");
        }
      }
    };
    var TotpMultiFactorGenerator2 = class {
      /**
       * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of
       * the TOTP (time-based one-time password) second factor.
       * This assertion is used to complete enrollment in TOTP second factor.
       *
       * @param secret A {@link TotpSecret} containing the shared secret key and other TOTP parameters.
       * @param oneTimePassword One-time password from TOTP App.
       * @returns A {@link TotpMultiFactorAssertion} which can be used with
       * {@link MultiFactorUser.enroll}.
       */
      static assertionForEnrollment(secret, oneTimePassword) {
        return TotpMultiFactorAssertionImpl2._fromSecret(secret, oneTimePassword);
      }
      /**
       * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of the TOTP second factor.
       * This assertion is used to complete signIn with TOTP as the second factor.
       *
       * @param enrollmentId identifies the enrolled TOTP second factor.
       * @param oneTimePassword One-time password from TOTP App.
       * @returns A {@link TotpMultiFactorAssertion} which can be used with
       * {@link MultiFactorResolver.resolveSignIn}.
       */
      static assertionForSignIn(enrollmentId, oneTimePassword) {
        return TotpMultiFactorAssertionImpl2._fromEnrollmentId(enrollmentId, oneTimePassword);
      }
      /**
       * Returns a promise to {@link TotpSecret} which contains the TOTP shared secret key and other parameters.
       * Creates a TOTP secret as part of enrolling a TOTP second factor.
       * Used for generating a QR code URL or inputting into a TOTP app.
       * This method uses the auth instance corresponding to the user in the multiFactorSession.
       *
       * @param session The {@link MultiFactorSession} that the user is part of.
       * @returns A promise to {@link TotpSecret}.
       */
      static async generateSecret(session) {
        const mfaSession = session;
        _assert2(
          typeof mfaSession.user?.auth !== "undefined",
          "internal-error"
          /* AuthErrorCode.INTERNAL_ERROR */
        );
        const response = await startEnrollTotpMfa2(mfaSession.user.auth, {
          idToken: mfaSession.credential,
          totpEnrollmentInfo: {}
        });
        return TotpSecret2._fromStartTotpMfaEnrollmentResponse(response, mfaSession.user.auth);
      }
    };
    TotpMultiFactorGenerator2.FACTOR_ID = "totp";
    var TotpMultiFactorAssertionImpl2 = class _TotpMultiFactorAssertionImpl extends MultiFactorAssertionImpl2 {
      constructor(otp, enrollmentId, secret) {
        super(
          "totp"
          /* FactorId.TOTP */
        );
        this.otp = otp;
        this.enrollmentId = enrollmentId;
        this.secret = secret;
      }
      /** @internal */
      static _fromSecret(secret, otp) {
        return new _TotpMultiFactorAssertionImpl(otp, void 0, secret);
      }
      /** @internal */
      static _fromEnrollmentId(enrollmentId, otp) {
        return new _TotpMultiFactorAssertionImpl(otp, enrollmentId);
      }
      /** @internal */
      async _finalizeEnroll(auth2, idToken, displayName) {
        _assert2(
          typeof this.secret !== "undefined",
          auth2,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        return finalizeEnrollTotpMfa2(auth2, {
          idToken,
          displayName,
          totpVerificationInfo: this.secret._makeTotpVerificationInfo(this.otp)
        });
      }
      /** @internal */
      async _finalizeSignIn(auth2, mfaPendingCredential) {
        _assert2(
          this.enrollmentId !== void 0 && this.otp !== void 0,
          auth2,
          "argument-error"
          /* AuthErrorCode.ARGUMENT_ERROR */
        );
        const totpVerificationInfo = { verificationCode: this.otp };
        return finalizeSignInTotpMfa2(auth2, {
          mfaPendingCredential,
          mfaEnrollmentId: this.enrollmentId,
          totpVerificationInfo
        });
      }
    };
    var TotpSecret2 = class _TotpSecret {
      // The public members are declared outside the constructor so the docs can be generated.
      constructor(secretKey, hashingAlgorithm, codeLength, codeIntervalSeconds, enrollmentCompletionDeadline, sessionInfo, auth2) {
        this.sessionInfo = sessionInfo;
        this.auth = auth2;
        this.secretKey = secretKey;
        this.hashingAlgorithm = hashingAlgorithm;
        this.codeLength = codeLength;
        this.codeIntervalSeconds = codeIntervalSeconds;
        this.enrollmentCompletionDeadline = enrollmentCompletionDeadline;
      }
      /** @internal */
      static _fromStartTotpMfaEnrollmentResponse(response, auth2) {
        return new _TotpSecret(response.totpSessionInfo.sharedSecretKey, response.totpSessionInfo.hashingAlgorithm, response.totpSessionInfo.verificationCodeLength, response.totpSessionInfo.periodSec, new Date(response.totpSessionInfo.finalizeEnrollmentTime).toUTCString(), response.totpSessionInfo.sessionInfo, auth2);
      }
      /** @internal */
      _makeTotpVerificationInfo(otp) {
        return { sessionInfo: this.sessionInfo, verificationCode: otp };
      }
      /**
       * Returns a QR code URL as described in
       * https://github.com/google/google-authenticator/wiki/Key-Uri-Format
       * This can be displayed to the user as a QR code to be scanned into a TOTP app like Google Authenticator.
       * If the optional parameters are unspecified, an accountName of <userEmail> and issuer of <firebaseAppName> are used.
       *
       * @param accountName the name of the account/app along with a user identifier.
       * @param issuer issuer of the TOTP (likely the app name).
       * @returns A QR code URL string.
       */
      generateQrCodeUrl(accountName, issuer) {
        let useDefaults = false;
        if (_isEmptyString2(accountName) || _isEmptyString2(issuer)) {
          useDefaults = true;
        }
        if (useDefaults) {
          if (_isEmptyString2(accountName)) {
            accountName = this.auth.currentUser?.email || "unknownuser";
          }
          if (_isEmptyString2(issuer)) {
            issuer = this.auth.name;
          }
        }
        return `otpauth://totp/${issuer}:${accountName}?secret=${this.secretKey}&issuer=${issuer}&algorithm=${this.hashingAlgorithm}&digits=${this.codeLength}`;
      }
    };
    function _isEmptyString2(input) {
      return typeof input === "undefined" || input?.length === 0;
    }
    exports2.AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY = AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY2;
    exports2.ActionCodeOperation = ActionCodeOperation2;
    exports2.ActionCodeURL = ActionCodeURL2;
    exports2.AuthCredential = AuthCredential2;
    exports2.AuthImpl = AuthImpl2;
    exports2.BaseOAuthProvider = BaseOAuthProvider2;
    exports2.EmailAuthCredential = EmailAuthCredential2;
    exports2.EmailAuthProvider = EmailAuthProvider2;
    exports2.FacebookAuthProvider = FacebookAuthProvider2;
    exports2.FactorId = FactorId2;
    exports2.FederatedAuthProvider = FederatedAuthProvider2;
    exports2.FetchProvider = FetchProvider2;
    exports2.GithubAuthProvider = GithubAuthProvider2;
    exports2.GoogleAuthProvider = GoogleAuthProvider2;
    exports2.OAuthCredential = OAuthCredential2;
    exports2.OAuthProvider = OAuthProvider2;
    exports2.OperationType = OperationType2;
    exports2.PhoneAuthCredential = PhoneAuthCredential2;
    exports2.PhoneAuthProvider = PhoneAuthProvider2;
    exports2.PhoneMultiFactorGenerator = PhoneMultiFactorGenerator2;
    exports2.ProviderId = ProviderId2;
    exports2.RecaptchaVerifier = RecaptchaVerifier2;
    exports2.SAMLAuthCredential = SAMLAuthCredential2;
    exports2.SAMLAuthProvider = SAMLAuthProvider2;
    exports2.SignInMethod = SignInMethod2;
    exports2.TotpMultiFactorGenerator = TotpMultiFactorGenerator2;
    exports2.TotpSecret = TotpSecret2;
    exports2.TwitterAuthProvider = TwitterAuthProvider2;
    exports2.UserImpl = UserImpl2;
    exports2._assert = _assert2;
    exports2._castAuth = _castAuth2;
    exports2._createError = _createError2;
    exports2._emulatorUrl = _emulatorUrl2;
    exports2._fail = _fail2;
    exports2._getClientVersion = _getClientVersion2;
    exports2._getInstance = _getInstance2;
    exports2._isAndroid = _isAndroid2;
    exports2._isIE10 = _isIE10;
    exports2._isIOS = _isIOS;
    exports2._isIOS7Or8 = _isIOS7Or8;
    exports2._isMobileBrowser = _isMobileBrowser;
    exports2._link = _link2;
    exports2._performApiRequest = _performApiRequest2;
    exports2._persistenceKeyName = _persistenceKeyName2;
    exports2._reauthenticate = _reauthenticate2;
    exports2._serverAppCurrentUserOperationNotSupportedError = _serverAppCurrentUserOperationNotSupportedError2;
    exports2._signInWithCredential = _signInWithCredential2;
    exports2.applyActionCode = applyActionCode2;
    exports2.beforeAuthStateChanged = beforeAuthStateChanged2;
    exports2.browserCookiePersistence = browserCookiePersistence2;
    exports2.browserLocalPersistence = browserLocalPersistence2;
    exports2.browserPopupRedirectResolver = browserPopupRedirectResolver2;
    exports2.browserSessionPersistence = browserSessionPersistence2;
    exports2.checkActionCode = checkActionCode2;
    exports2.confirmPasswordReset = confirmPasswordReset2;
    exports2.connectAuthEmulator = connectAuthEmulator2;
    exports2.createUserWithEmailAndPassword = createUserWithEmailAndPassword2;
    exports2.debugAssert = debugAssert2;
    exports2.debugErrorMap = debugErrorMap2;
    exports2.deleteUser = deleteUser2;
    exports2.fetchSignInMethodsForEmail = fetchSignInMethodsForEmail2;
    exports2.getAdditionalUserInfo = getAdditionalUserInfo2;
    exports2.getAuth = getAuth2;
    exports2.getIdToken = getIdToken2;
    exports2.getIdTokenResult = getIdTokenResult2;
    exports2.getMultiFactorResolver = getMultiFactorResolver2;
    exports2.getRedirectResult = getRedirectResult2;
    exports2.inMemoryPersistence = inMemoryPersistence2;
    exports2.indexedDBLocalPersistence = indexedDBLocalPersistence2;
    exports2.initializeAuth = initializeAuth2;
    exports2.initializeRecaptchaConfig = initializeRecaptchaConfig2;
    exports2.isSignInWithEmailLink = isSignInWithEmailLink2;
    exports2.linkWithCredential = linkWithCredential2;
    exports2.linkWithPhoneNumber = linkWithPhoneNumber2;
    exports2.linkWithPopup = linkWithPopup2;
    exports2.linkWithRedirect = linkWithRedirect2;
    exports2.multiFactor = multiFactor2;
    exports2.onAuthStateChanged = onAuthStateChanged2;
    exports2.onIdTokenChanged = onIdTokenChanged2;
    exports2.parseActionCodeURL = parseActionCodeURL2;
    exports2.prodErrorMap = prodErrorMap2;
    exports2.reauthenticateWithCredential = reauthenticateWithCredential2;
    exports2.reauthenticateWithPhoneNumber = reauthenticateWithPhoneNumber2;
    exports2.reauthenticateWithPopup = reauthenticateWithPopup2;
    exports2.reauthenticateWithRedirect = reauthenticateWithRedirect2;
    exports2.reload = reload2;
    exports2.revokeAccessToken = revokeAccessToken2;
    exports2.sendEmailVerification = sendEmailVerification2;
    exports2.sendPasswordResetEmail = sendPasswordResetEmail2;
    exports2.sendSignInLinkToEmail = sendSignInLinkToEmail2;
    exports2.setPersistence = setPersistence2;
    exports2.signInAnonymously = signInAnonymously2;
    exports2.signInWithCredential = signInWithCredential2;
    exports2.signInWithCustomToken = signInWithCustomToken2;
    exports2.signInWithEmailAndPassword = signInWithEmailAndPassword2;
    exports2.signInWithEmailLink = signInWithEmailLink2;
    exports2.signInWithIdp = signInWithIdp2;
    exports2.signInWithPhoneNumber = signInWithPhoneNumber2;
    exports2.signInWithPopup = signInWithPopup2;
    exports2.signInWithRedirect = signInWithRedirect2;
    exports2.signOut = signOut2;
    exports2.unlink = unlink2;
    exports2.updateCurrentUser = updateCurrentUser2;
    exports2.updateEmail = updateEmail2;
    exports2.updatePassword = updatePassword2;
    exports2.updatePhoneNumber = updatePhoneNumber2;
    exports2.updateProfile = updateProfile2;
    exports2.useDeviceLanguage = useDeviceLanguage2;
    exports2.validatePassword = validatePassword2;
    exports2.verifyBeforeUpdateEmail = verifyBeforeUpdateEmail2;
    exports2.verifyPasswordResetCode = verifyPasswordResetCode2;
  }
});

// node_modules/@firebase/auth/dist/node/index.js
var require_node = __commonJS({
  "node_modules/@firebase/auth/dist/node/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var totp = require_totp_50d5d5dd();
    require_index_cjs3();
    require_index_node_cjs();
    require_index_cjs();
    require_index_cjs2();
    exports2.ActionCodeOperation = totp.ActionCodeOperation;
    exports2.ActionCodeURL = totp.ActionCodeURL;
    exports2.AuthCredential = totp.AuthCredential;
    exports2.AuthErrorCodes = totp.AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY;
    exports2.EmailAuthCredential = totp.EmailAuthCredential;
    exports2.EmailAuthProvider = totp.EmailAuthProvider;
    exports2.FacebookAuthProvider = totp.FacebookAuthProvider;
    exports2.FactorId = totp.FactorId;
    exports2.GithubAuthProvider = totp.GithubAuthProvider;
    exports2.GoogleAuthProvider = totp.GoogleAuthProvider;
    exports2.OAuthCredential = totp.OAuthCredential;
    exports2.OAuthProvider = totp.OAuthProvider;
    exports2.OperationType = totp.OperationType;
    exports2.PhoneAuthCredential = totp.PhoneAuthCredential;
    exports2.PhoneAuthProvider = totp.PhoneAuthProvider;
    exports2.PhoneMultiFactorGenerator = totp.PhoneMultiFactorGenerator;
    exports2.ProviderId = totp.ProviderId;
    exports2.RecaptchaVerifier = totp.RecaptchaVerifier;
    exports2.SAMLAuthProvider = totp.SAMLAuthProvider;
    exports2.SignInMethod = totp.SignInMethod;
    exports2.TotpMultiFactorGenerator = totp.TotpMultiFactorGenerator;
    exports2.TotpSecret = totp.TotpSecret;
    exports2.TwitterAuthProvider = totp.TwitterAuthProvider;
    exports2.applyActionCode = totp.applyActionCode;
    exports2.beforeAuthStateChanged = totp.beforeAuthStateChanged;
    exports2.browserCookiePersistence = totp.browserCookiePersistence;
    exports2.browserLocalPersistence = totp.browserLocalPersistence;
    exports2.browserPopupRedirectResolver = totp.browserPopupRedirectResolver;
    exports2.browserSessionPersistence = totp.browserSessionPersistence;
    exports2.checkActionCode = totp.checkActionCode;
    exports2.confirmPasswordReset = totp.confirmPasswordReset;
    exports2.connectAuthEmulator = totp.connectAuthEmulator;
    exports2.createUserWithEmailAndPassword = totp.createUserWithEmailAndPassword;
    exports2.debugErrorMap = totp.debugErrorMap;
    exports2.deleteUser = totp.deleteUser;
    exports2.fetchSignInMethodsForEmail = totp.fetchSignInMethodsForEmail;
    exports2.getAdditionalUserInfo = totp.getAdditionalUserInfo;
    exports2.getAuth = totp.getAuth;
    exports2.getIdToken = totp.getIdToken;
    exports2.getIdTokenResult = totp.getIdTokenResult;
    exports2.getMultiFactorResolver = totp.getMultiFactorResolver;
    exports2.getRedirectResult = totp.getRedirectResult;
    exports2.inMemoryPersistence = totp.inMemoryPersistence;
    exports2.indexedDBLocalPersistence = totp.indexedDBLocalPersistence;
    exports2.initializeAuth = totp.initializeAuth;
    exports2.initializeRecaptchaConfig = totp.initializeRecaptchaConfig;
    exports2.isSignInWithEmailLink = totp.isSignInWithEmailLink;
    exports2.linkWithCredential = totp.linkWithCredential;
    exports2.linkWithPhoneNumber = totp.linkWithPhoneNumber;
    exports2.linkWithPopup = totp.linkWithPopup;
    exports2.linkWithRedirect = totp.linkWithRedirect;
    exports2.multiFactor = totp.multiFactor;
    exports2.onAuthStateChanged = totp.onAuthStateChanged;
    exports2.onIdTokenChanged = totp.onIdTokenChanged;
    exports2.parseActionCodeURL = totp.parseActionCodeURL;
    exports2.prodErrorMap = totp.prodErrorMap;
    exports2.reauthenticateWithCredential = totp.reauthenticateWithCredential;
    exports2.reauthenticateWithPhoneNumber = totp.reauthenticateWithPhoneNumber;
    exports2.reauthenticateWithPopup = totp.reauthenticateWithPopup;
    exports2.reauthenticateWithRedirect = totp.reauthenticateWithRedirect;
    exports2.reload = totp.reload;
    exports2.revokeAccessToken = totp.revokeAccessToken;
    exports2.sendEmailVerification = totp.sendEmailVerification;
    exports2.sendPasswordResetEmail = totp.sendPasswordResetEmail;
    exports2.sendSignInLinkToEmail = totp.sendSignInLinkToEmail;
    exports2.setPersistence = totp.setPersistence;
    exports2.signInAnonymously = totp.signInAnonymously;
    exports2.signInWithCredential = totp.signInWithCredential;
    exports2.signInWithCustomToken = totp.signInWithCustomToken;
    exports2.signInWithEmailAndPassword = totp.signInWithEmailAndPassword;
    exports2.signInWithEmailLink = totp.signInWithEmailLink;
    exports2.signInWithPhoneNumber = totp.signInWithPhoneNumber;
    exports2.signInWithPopup = totp.signInWithPopup;
    exports2.signInWithRedirect = totp.signInWithRedirect;
    exports2.signOut = totp.signOut;
    exports2.unlink = totp.unlink;
    exports2.updateCurrentUser = totp.updateCurrentUser;
    exports2.updateEmail = totp.updateEmail;
    exports2.updatePassword = totp.updatePassword;
    exports2.updatePhoneNumber = totp.updatePhoneNumber;
    exports2.updateProfile = totp.updateProfile;
    exports2.useDeviceLanguage = totp.useDeviceLanguage;
    exports2.validatePassword = totp.validatePassword;
    exports2.verifyBeforeUpdateEmail = totp.verifyBeforeUpdateEmail;
    exports2.verifyPasswordResetCode = totp.verifyPasswordResetCode;
  }
});

// node_modules/firebase/auth/dist/index.cjs.js
var require_index_cjs4 = __commonJS({
  "node_modules/firebase/auth/dist/index.cjs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var auth2 = require_node();
    Object.keys(auth2).forEach(function(k) {
      if (k !== "default" && !exports2.hasOwnProperty(k)) Object.defineProperty(exports2, k, {
        enumerable: true,
        get: function() {
          return auth2[k];
        }
      });
    });
  }
});

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => UuuglPlugin
});
module.exports = __toCommonJS(main_exports);
var import_obsidian4 = require("obsidian");

// src/auth-manager.ts
init_firebase_config();
init_dist2();
var import_obsidian = require("obsidian");
var AuthManager = class {
  constructor() {
    this.authCallbacks = /* @__PURE__ */ new Map();
    this.AUTH_URL = "https://uuu.gl/auth/obsidian";
  }
  /**
   * Sign in with Google OAuth (cross-platform)
   * Opens browser for authentication, returns to Obsidian via obsidian:// URL
   */
  async signInWithGoogle() {
    return new Promise((resolve, reject) => {
      const callbackId = `auth-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
      console.log("\u{1F510} Starting cross-platform OAuth flow...");
      this.authCallbacks.set(callbackId, async (customToken) => {
        try {
          console.log("\u{1F511} Received custom token, authenticating with Firebase...");
          const userCredential = await signInWithCustomToken(auth, customToken);
          const user = userCredential.user;
          console.log("\u2705 Firebase authentication successful:", user.email);
          const authUser = {
            uid: user.uid,
            email: user.email,
            displayName: user.displayName,
            photoURL: user.photoURL
          };
          this.authCallbacks.delete(callbackId);
          resolve(authUser);
        } catch (error) {
          console.error("\u274C Firebase authentication failed:", error);
          this.authCallbacks.delete(callbackId);
          reject(error);
        }
      });
      const authUrl = `${this.AUTH_URL}?callbackId=${callbackId}`;
      console.log("\u{1F517} Opening browser for authentication...");
      console.log("Platform:", import_obsidian.Platform.isDesktopApp ? "Desktop" : import_obsidian.Platform.isMobileApp ? "Mobile" : "Unknown");
      this.openExternalBrowser(authUrl);
      setTimeout(() => {
        if (this.authCallbacks.has(callbackId)) {
          this.authCallbacks.delete(callbackId);
          reject(new Error("Authentication timeout"));
        }
      }, 5 * 60 * 1e3);
    });
  }
  /**
   * Open external browser (cross-platform)
   */
  openExternalBrowser(url) {
    try {
      if (import_obsidian.Platform.isDesktopApp) {
        const { shell } = require("electron");
        shell.openExternal(url);
        console.log("\u{1F5A5}\uFE0F Opened browser via Electron shell");
      } else {
        const globalWindow = window;
        if (globalWindow.app && typeof globalWindow.app.openExternal === "function") {
          globalWindow.app.openExternal(url);
          console.log("\u{1F4F1} Opened browser via Obsidian mobile API");
        } else {
          window.open(url, "_blank");
          console.log("\u{1F310} Opened browser via window.open");
        }
      }
    } catch (error) {
      console.error("\u274C Failed to open browser:", error);
      new import_obsidian.Notice("Failed to open browser. Please open this link manually:");
      new import_obsidian.Notice(url);
    }
  }
  /**
   * Handle obsidian:// URL callback
   * Called by main.ts when URI is opened
   */
  handleCallback(uri) {
    try {
      console.log("\u{1F517} Handling callback URI:", uri);
      const url = new URL(uri);
      if (!url.pathname.includes("callback")) {
        return false;
      }
      const callbackId = url.searchParams.get("callbackId");
      const token = url.searchParams.get("token");
      const error = url.searchParams.get("error");
      if (error) {
        console.error("\u274C Auth callback error:", error);
        new import_obsidian.Notice(`\u274C Authentication failed: ${error}`);
        this.authCallbacks.clear();
        return true;
      }
      if (!callbackId || !token) {
        console.error("\u274C Invalid callback URI: missing callbackId or token");
        return false;
      }
      const callback = this.authCallbacks.get(callbackId);
      if (callback) {
        console.log("\u2705 Found callback, executing...");
        callback(token);
        return true;
      } else {
        console.warn("\u26A0\uFE0F No callback found for callbackId:", callbackId);
        return false;
      }
    } catch (error) {
      console.error("\u274C Failed to handle callback:", error);
      return false;
    }
  }
  /**
   * Sign out
   */
  async signOut() {
    await auth.signOut();
    console.log("\u{1F44B} Signed out");
  }
  /**
   * Get current authenticated user
   */
  getCurrentUser() {
    const user = auth.currentUser;
    if (!user) return null;
    return {
      uid: user.uid,
      email: user.email,
      displayName: user.displayName,
      photoURL: user.photoURL
    };
  }
  /**
   * Get current authenticated user email
   */
  getCurrentUserEmail() {
    return auth.currentUser?.email || null;
  }
  /**
   * Check if user is authenticated
   */
  isAuthenticated() {
    return !!auth.currentUser;
  }
  /**
   * Get Firebase ID token
   */
  async getIdToken() {
    const token = await auth.currentUser?.getIdToken();
    if (!token) {
      throw new Error("No authentication token available");
    }
    return token;
  }
};

// src/upload-modal.ts
var import_obsidian2 = require("obsidian");

// src/markdown-extractor.ts
var MarkdownExtractor = class {
  constructor(app2, vault) {
    this.app = app2;
    this.vault = vault;
  }
  /**
   * Extract markdown content, images, and internal links from a file
   */
  async extractMarkdown(file) {
    const content = await this.vault.read(file);
    const internalLinks = this.extractInternalLinks(content);
    const images = await this.extractImages(content, file);
    return {
      content,
      images,
      internalLinks
    };
  }
  /**
   * Extract internal links from markdown content
   * Matches [[link]] and [[display|link]] patterns
   */
  extractInternalLinks(content) {
    const regex = /\[\[([^\]]+)\]\]/g;
    const links = [];
    let match;
    while ((match = regex.exec(content)) !== null) {
      const startIndex = match.index;
      if (startIndex > 0 && content[startIndex - 1] === "!") {
        continue;
      }
      const linkText = match[1];
      const parts = linkText.split("|");
      const target = parts.length > 1 ? parts[1].trim() : parts[0].trim();
      links.push(target);
    }
    return [...new Set(links)];
  }
  /**
   * Extract and read image files from markdown content
   */
  async extractImages(content, sourceFile) {
    const images = [];
    const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)|!\[\[([^\]]+)\]\]/g;
    let match;
    while ((match = imageRegex.exec(content)) !== null) {
      let altText;
      let imagePath;
      if (match[2]) {
        altText = match[1] || void 0;
        imagePath = match[2];
      } else {
        imagePath = match[3];
        altText = void 0;
      }
      try {
        const imageFile = this.app.metadataCache.getFirstLinkpathDest(
          imagePath,
          sourceFile.path
        );
        if (!imageFile) {
          console.warn(`\u26A0\uFE0F Image not found in vault: ${imagePath}`);
          console.warn(`Source file path: ${sourceFile.path}`);
          console.warn(`Looking for: ${imagePath}`);
          continue;
        }
        const data = await this.vault.readBinary(imageFile);
        const mimeType = this.getMimeType(imageFile.extension);
        images.push({
          name: imageFile.name,
          data,
          mimeType,
          size: data.byteLength,
          altText,
          originalPath: imagePath
        });
        console.log(`\u{1F4F7} Extracted image: ${imageFile.name} (${(data.byteLength / 1024).toFixed(1)}KB)`);
      } catch (error) {
        console.error(`\u274C Failed to read image: ${imagePath}`, error);
      }
    }
    return images;
  }
  /**
   * Get MIME type from file extension
   */
  getMimeType(extension) {
    const mimeTypes = {
      "png": "image/png",
      "jpg": "image/jpeg",
      "jpeg": "image/jpeg",
      "gif": "image/gif",
      "svg": "image/svg+xml",
      "webp": "image/webp",
      "bmp": "image/bmp"
    };
    return mimeTypes[extension.toLowerCase()] || "application/octet-stream";
  }
};

// src/image-uploader.ts
init_firebase_config();
init_dist4();
var ImageUploader = class {
  /**
   * Upload images to Firebase Storage
   * @param images Array of images to upload
   * @param memoId Memo ID for storage path
   * @returns Array of uploaded image metadata
   */
  async uploadImages(images, memoId) {
    const uploadedImages = [];
    for (let i = 0; i < images.length; i++) {
      const image = images[i];
      try {
        console.log(`\u{1F4E4} Uploading image ${i + 1}/${images.length}: ${image.name}...`);
        console.log(`   Size: ${(image.size / 1024).toFixed(1)}KB`);
        console.log(`   Type: ${image.mimeType}`);
        const timestamp = Date.now();
        const sanitizedName = this.sanitizeFileName(image.name);
        const storagePath = `memos/${memoId}/images/${timestamp}_${sanitizedName}`;
        console.log(`   Storage path: ${storagePath}`);
        const storageRef = ref(storage, storagePath);
        const blob = new Blob([image.data], { type: image.mimeType });
        console.log(`   Blob created: ${blob.size} bytes`);
        console.log(`   Starting upload...`);
        const snapshot = await uploadBytes(storageRef, blob, {
          contentType: image.mimeType
        });
        const downloadUrl = await getDownloadURL(snapshot.ref);
        console.log(`   Download URL: ${downloadUrl}`);
        uploadedImages.push({
          originalName: image.name,
          storagePath: snapshot.ref.fullPath,
          downloadUrl,
          mimeType: image.mimeType,
          size: image.size,
          altText: image.altText
        });
        console.log(`\u2705 Image uploaded successfully: ${image.name}`);
      } catch (error) {
        console.error(`\u274C Failed to upload image: ${image.name}`, error);
        console.error("Error code:", error.code);
        console.error("Error message:", error.message);
        console.error("Full error:", JSON.stringify(error, null, 2));
        const errorMsg = error.code === "storage/unauthorized" ? "Storage permission denied. Please check Firebase Storage rules." : error.message || error.code || "Unknown error";
        throw new Error(`Failed to upload image: ${image.name}
${errorMsg}`);
      }
    }
    return uploadedImages;
  }
  /**
   * Sanitize file name for storage
   */
  sanitizeFileName(fileName) {
    return fileName.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/_{2,}/g, "_").toLowerCase();
  }
  /**
   * Replace image paths in markdown content with uploaded URLs
   */
  replaceImagePaths(content, originalImages, uploadedImages) {
    let updatedContent = content;
    for (let i = 0; i < originalImages.length; i++) {
      const original = originalImages[i];
      const uploaded = uploadedImages[i];
      if (!uploaded) continue;
      const wikiRegex = new RegExp(`!\\[\\[${this.escapeRegex(original.originalPath)}\\]\\]`, "g");
      updatedContent = updatedContent.replace(
        wikiRegex,
        `![${uploaded.altText || uploaded.originalName}](${uploaded.downloadUrl})`
      );
      const mdRegex = new RegExp(`!\\[([^\\]]*)\\]\\(${this.escapeRegex(original.originalPath)}\\)`, "g");
      updatedContent = updatedContent.replace(
        mdRegex,
        `![$1](${uploaded.downloadUrl})`
      );
    }
    return updatedContent;
  }
  /**
   * Escape special regex characters
   */
  escapeRegex(str) {
    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  }
};

// src/memo-uploader.ts
init_firebase_config();
init_dist3();
var MemoUploader = class {
  /**
   * Create a new Markdown memo
   */
  async createMemo(shortCode, password) {
    console.log(`\u{1F4DD} Creating memo with shortCode: ${shortCode}`);
    if (password) {
      console.log(`\u{1F512} Password protection enabled`);
    }
    const createMemoFunction = httpsCallable(functions, "createMemo");
    const request = {
      shortCode,
      isPublic: true,
      contentType: "markdown"
    };
    if (password) {
      request.password = password;
    }
    const result = await createMemoFunction(request);
    const data = result.data;
    if (!data.success) {
      throw new Error(data.error || "Failed to create memo");
    }
    console.log(`\u2705 Memo created: ${data.memoId}`);
    return {
      memoId: data.memoId,
      shortCode: data.shortCode
    };
  }
  /**
   * Save markdown content to memo
   */
  async saveMemo(memoId, shortCode, content, images, internalLinks, version6, password) {
    console.log(`\u{1F4BE} Saving memo: ${shortCode}`);
    const saveMemoFunction = httpsCallable(functions, "saveMemo");
    const request = {
      shortCode,
      memoId,
      markdownData: {
        content,
        images: images.map((img, index) => ({
          id: `img_${index}`,
          storagePath: img.storagePath,
          originalName: img.originalName,
          mimeType: img.mimeType,
          size: img.size,
          altText: img.altText
        })),
        internalLinks
      },
      version: version6
    };
    if (password) {
      request.password = password;
    }
    const result = await saveMemoFunction(request);
    const data = result.data;
    if (!data.success) {
      throw new Error(data.error || "Failed to save memo");
    }
    console.log(`\u2705 Memo saved successfully. Version: ${data.version}`);
    return {
      success: true,
      memoId,
      shortCode,
      url: `https://uuu.gl/md/${shortCode}`,
      version: data.version || 0
    };
  }
  /**
   * Complete upload workflow: create + save
   */
  async uploadMarkdown(shortCode, content, images, internalLinks) {
    const { memoId, shortCode: finalShortCode } = await this.createMemo(shortCode);
    const result = await this.saveMemo(
      memoId,
      finalShortCode,
      content,
      images,
      internalLinks,
      0
      // Initial version
    );
    return result;
  }
};

// src/upload-modal.ts
init_dist3();
init_firebase_config();
var UploadModal = class extends import_obsidian2.Modal {
  constructor(app2, file, authManager, plugin, defaultPrefix = "obsidian") {
    super(app2);
    this.keyword1Input = null;
    this.keyword2Input = null;
    this.passwordInput = null;
    this.urlPreviewEl = null;
    this.progressEl = null;
    this.progressBar = null;
    this.progressText = null;
    this.resultEl = null;
    this.mainContent = null;
    this.existingUrl = null;
    this.file = file;
    this.authManager = authManager;
    this.plugin = plugin;
    this.defaultPrefix = defaultPrefix;
  }
  async onOpen() {
    const { contentEl } = this;
    contentEl.addClass("uuugl-upload-modal");
    const header = contentEl.createDiv({ cls: "uuugl-modal-header" });
    header.createEl("h2", { text: "Upload note to uuu.gl" });
    header.createEl("p", {
      text: `File: ${this.file.basename}`,
      cls: "uuugl-file-name"
    });
    this.mainContent = contentEl.createDiv({ cls: "uuugl-modal-content" });
    this.progressEl = contentEl.createDiv({ cls: "uuugl-progress" });
    this.progressText = this.progressEl.createDiv({ cls: "uuugl-progress-text" });
    const progressBarContainer = this.progressEl.createDiv({ cls: "uuugl-progress-bar-container" });
    this.progressBar = progressBarContainer.createDiv({ cls: "uuugl-progress-bar-fill" });
    this.progressEl.hide();
    this.resultEl = contentEl.createDiv({ cls: "uuugl-result" });
    this.resultEl.hide();
    this.existingUrl = await this.checkExistingMemo();
    if (this.existingUrl) {
      this.renderExistingMemoUI(this.existingUrl);
    } else {
      this.renderNewMemoUI();
    }
  }
  onClose() {
    const { contentEl } = this;
    contentEl.empty();
  }
  /**
   * Check if the file already has a uuu.gl link (memory cache or frontmatter)
   */
  async checkExistingMemo() {
    try {
      const cachedUrl = this.plugin.urlCache.get(this.file.path);
      if (cachedUrl) {
        console.log("\u2705 Found URL in memory cache:", cachedUrl);
        return cachedUrl;
      }
      const content = await this.app.vault.read(this.file);
      const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
      const match = content.match(frontmatterRegex);
      if (!match) return null;
      const frontmatter = match[1];
      const lines = frontmatter.split("\n");
      for (const line of lines) {
        if (line.startsWith("uuugl:")) {
          const url = line.replace("uuugl:", "").trim();
          if (url) {
            this.plugin.setUuuglUrl(this.file, url);
            console.log("\u2705 Found URL in frontmatter:", url);
            return url;
          }
        }
      }
      return null;
    } catch (error) {
      console.error("Failed to check existing memo:", error);
      return null;
    }
  }
  /**
   * Render UI for existing memo (Copy/Update/Delete)
   */
  renderExistingMemoUI(url) {
    if (!this.mainContent) return;
    this.mainContent.empty();
    const shortCode = url.replace("https://uuu.gl/", "");
    const infoSection = this.mainContent.createDiv({ cls: "uuugl-existing-memo-section" });
    const infoTitle = infoSection.createEl("div", {
      text: "\u2705 This note is already uploaded",
      cls: "uuugl-existing-memo-title"
    });
    const urlDisplay = infoSection.createEl("a", {
      text: url,
      href: url,
      cls: "uuugl-existing-memo-url"
    });
    urlDisplay.setAttribute("target", "_blank");
    const uploadDate = this.mainContent.createDiv({ cls: "uuugl-existing-memo-date" });
    uploadDate.setText("\u{1F5D3}\uFE0F You can update the memo content or delete it to create a new one");
    this.mainContent.createDiv({ cls: "uuugl-section-divider" });
    const buttonsSection = this.mainContent.createDiv({ cls: "uuugl-existing-memo-buttons" });
    const copyButton = buttonsSection.createEl("button", {
      text: "\u{1F4CE} Copy Link",
      cls: "uuugl-btn uuugl-btn-secondary"
    });
    copyButton.addEventListener("click", () => {
      navigator.clipboard.writeText(url);
      new import_obsidian2.Notice("\u{1F4CE} Link copied to clipboard!");
    });
    const updateButton = buttonsSection.createEl("button", {
      text: "\u{1F504} Update Memo",
      cls: "uuugl-btn uuugl-btn-primary"
    });
    updateButton.addEventListener("click", () => this.handleUpdateMemo(shortCode));
    const deleteButton = buttonsSection.createEl("button", {
      text: "\u{1F5D1}\uFE0F Delete Memo",
      cls: "uuugl-btn uuugl-btn-danger"
    });
    deleteButton.addEventListener("click", () => this.handleDeleteMemo(shortCode));
  }
  /**
   * Render UI for new memo upload
   */
  renderNewMemoUI() {
    if (!this.mainContent) return;
    this.mainContent.empty();
    const passwordSection = this.mainContent.createDiv({ cls: "setting-item uuugl-setting-item" });
    const passwordInfo = passwordSection.createDiv({ cls: "setting-item-info" });
    passwordInfo.createDiv({ cls: "setting-item-name", text: "Password protection" });
    passwordInfo.createDiv({ cls: "setting-item-description", text: "Optional: Set a password to protect your note" });
    const passwordControl = passwordSection.createDiv({ cls: "setting-item-control" });
    this.passwordInput = passwordControl.createEl("input", {
      type: "password",
      placeholder: "Enter password (optional)",
      cls: "uuugl-password-input"
    });
    const divider1 = this.mainContent.createDiv({ cls: "uuugl-section-divider" });
    const urlOptionsHeader = this.mainContent.createDiv({ cls: "uuugl-section-header" });
    urlOptionsHeader.createEl("h3", { text: "Choose URL type", cls: "uuugl-section-title" });
    urlOptionsHeader.createEl("p", {
      text: "Create a custom memorable URL or generate a random short code",
      cls: "uuugl-section-description"
    });
    const customUrlSection = this.mainContent.createDiv({ cls: "uuugl-option-section" });
    const customUrlLabel = customUrlSection.createDiv({ cls: "uuugl-option-label" });
    customUrlLabel.createEl("span", { text: "\u{1F3AF} Custom URL", cls: "uuugl-option-title" });
    customUrlLabel.createEl("span", {
      text: "keyword1/keyword2",
      cls: "uuugl-option-badge"
    });
    const customUrlDesc = customUrlSection.createDiv({ cls: "uuugl-option-description" });
    customUrlDesc.setText("Create a memorable URL with custom keywords");
    const urlInputContainer = customUrlSection.createDiv({ cls: "uuugl-url-input-container" });
    urlInputContainer.createEl("span", {
      text: "uuu.gl/",
      cls: "uuugl-url-prefix"
    });
    this.keyword1Input = urlInputContainer.createEl("input", {
      type: "text",
      placeholder: "keyword1",
      cls: "uuugl-keyword-input"
    });
    urlInputContainer.createEl("span", {
      text: "/",
      cls: "uuugl-url-separator"
    });
    this.keyword2Input = urlInputContainer.createEl("input", {
      type: "text",
      placeholder: "keyword2",
      cls: "uuugl-keyword-input"
    });
    const customUrlButton = customUrlSection.createEl("button", {
      text: "Create Custom URL",
      cls: "uuugl-btn uuugl-btn-primary"
    });
    customUrlButton.addEventListener("click", () => this.handleUpload());
    const orDivider = this.mainContent.createDiv({ cls: "uuugl-divider" });
    orDivider.createEl("span", { text: "or" });
    const randomUrlSection = this.mainContent.createDiv({ cls: "uuugl-option-section" });
    const randomUrlLabel = randomUrlSection.createDiv({ cls: "uuugl-option-label" });
    randomUrlLabel.createEl("span", { text: "\u{1F3B2} Random URL", cls: "uuugl-option-title" });
    randomUrlLabel.createEl("span", {
      text: "Quick & easy",
      cls: "uuugl-option-badge uuugl-option-badge-secondary"
    });
    const randomUrlDesc = randomUrlSection.createDiv({ cls: "uuugl-option-description" });
    randomUrlDesc.setText("Automatically generate a short random code");
    const randomButton = randomUrlSection.createEl("button", {
      text: "Generate Random URL",
      cls: "uuugl-btn uuugl-btn-secondary"
    });
    randomButton.addEventListener("click", async () => {
      if (this.keyword1Input && this.keyword2Input) {
        this.keyword1Input.value = this.generateRandomShortCode();
        this.keyword2Input.value = "";
        this.updateUrlPreview();
        await this.handleUpload();
      }
    });
    const sanitizedName = this.sanitizeShortCode(this.file.basename);
    if (this.keyword1Input && this.keyword2Input) {
      this.keyword1Input.value = this.defaultPrefix;
      this.keyword2Input.value = sanitizedName;
    }
    this.keyword1Input.addEventListener("input", () => this.updateUrlPreview());
    this.keyword2Input.addEventListener("input", () => this.updateUrlPreview());
    this.urlPreviewEl = this.contentEl.createDiv({ cls: "uuugl-url-preview" });
    this.urlPreviewEl.hide();
    if (this.keyword1Input) {
      this.keyword1Input.focus();
      this.keyword1Input.select();
    }
  }
  /**
   * Handle memo update
   */
  async handleUpdateMemo(shortCode) {
    try {
      this.progressEl?.show();
      this.resultEl?.hide();
      if (this.mainContent) this.mainContent.hide();
      this.updateProgress("\u{1F510} Authenticating...", 10);
      if (!this.authManager.isAuthenticated()) {
        throw new Error("Not authenticated. Please configure your email in settings.");
      }
      this.updateProgress("\u{1F4C4} Extracting markdown content...", 30);
      const extractor = new MarkdownExtractor(this.app, this.app.vault);
      const extracted = await extractor.extractMarkdown(this.file);
      console.log(`\u{1F4CA} Extracted: ${extracted.images.length} images, ${extracted.internalLinks.length} internal links`);
      this.updateProgress("\u{1F50D} Looking up memo...", 50);
      const memoUploader = new MemoUploader();
      const getMemoFn = httpsCallable(functions, "getMemo");
      const getMemoResult = await getMemoFn({ shortCode });
      const memoData = getMemoResult.data;
      if (!memoData.success || !memoData.memo) {
        throw new Error("Memo not found. Unable to update.");
      }
      const memoId = memoData.memo.memoId;
      const currentVersion = memoData.memo.version || 0;
      console.log(`\u{1F4DD} Found memo ID: ${memoId}, version: ${currentVersion}`);
      let updatedContent = extracted.content;
      if (extracted.images.length > 0) {
        this.updateProgress(`\u{1F4E4} Uploading ${extracted.images.length} image(s)...`, 70);
        const imageUploader = new ImageUploader();
        const uploadedImages = await imageUploader.uploadImages(extracted.images, memoId);
        updatedContent = imageUploader.replaceImagePaths(
          extracted.content,
          extracted.images,
          uploadedImages
        );
      }
      this.updateProgress("\u{1F4BE} Updating memo...", 90);
      await memoUploader.saveMemo(
        memoId,
        shortCode,
        updatedContent,
        extracted.images.length > 0 ? [] : [],
        extracted.internalLinks,
        currentVersion,
        // Fix: Pass current version for proper version control
        null
        // Password not changeable on update
      );
      this.updateProgress("\u2705 Update complete!", 100);
      const displayUrl = `https://uuu.gl/${shortCode}`;
      this.plugin.setUuuglUrl(this.file, displayUrl);
      await this.plugin.saveUrlCache();
      await this.plugin.updateStatusBar();
      this.showSuccess(displayUrl, "Memo updated successfully!");
    } catch (error) {
      console.error("\u274C Update failed:", error);
      this.showError(error.message || "Update failed");
      if (this.mainContent) this.mainContent.show();
    }
  }
  /**
   * Handle memo deletion
   */
  async handleDeleteMemo(shortCode) {
    try {
      const confirmed = confirm(
        `Are you sure you want to delete this memo?

URL: https://uuu.gl/${shortCode}

This will remove the memo from uuu.gl and clear the frontmatter. You can then create a new memo with a different URL.`
      );
      if (!confirmed) return;
      this.progressEl?.show();
      this.resultEl?.hide();
      if (this.mainContent) this.mainContent.hide();
      this.updateProgress("\u{1F510} Authenticating...", 20);
      if (!this.authManager.isAuthenticated()) {
        throw new Error("Not authenticated. Please configure your email in settings.");
      }
      this.updateProgress("\u{1F5D1}\uFE0F Deleting memo from server...", 50);
      const deleteMemoFn = httpsCallable(functions, "deleteMemo");
      await deleteMemoFn({ shortCode });
      this.updateProgress("\u2705 Deletion complete!", 100);
      this.plugin.removeUuuglUrl(this.file);
      await this.plugin.saveUrlCache();
      await this.plugin.updateStatusBar();
      setTimeout(() => {
        this.progressEl?.hide();
        new import_obsidian2.Notice("\u2705 Memo deleted successfully! You can now create a new one.");
        this.existingUrl = null;
        this.renderNewMemoUI();
        if (this.mainContent) this.mainContent.show();
      }, 1e3);
    } catch (error) {
      console.error("\u274C Deletion failed:", error);
      this.showError(error.message || "Deletion failed");
      if (this.mainContent) this.mainContent.show();
    }
  }
  updateUrlPreview() {
    if (!this.urlPreviewEl || !this.keyword1Input) return;
    const keyword1 = this.keyword1Input.value.trim();
    const keyword2 = this.keyword2Input?.value.trim() || "";
    let previewUrl = "https://uuu.gl/";
    if (keyword1 && keyword2) {
      previewUrl += `${keyword1}/${keyword2}`;
    } else if (keyword1) {
      previewUrl += keyword1;
    } else {
      previewUrl += "[enter-keyword]";
    }
    this.urlPreviewEl.empty();
    this.urlPreviewEl.createEl("span", {
      text: `\u{1F4CE} Your note will be accessible at: `,
      cls: "upload-modal-url-label"
    });
    const urlText = this.urlPreviewEl.createEl("span", {
      text: previewUrl,
      cls: "upload-modal-url-text"
    });
    urlText.style.fontWeight = "bold";
    urlText.style.color = "#5b21b6";
  }
  async handleUpload() {
    if (!this.keyword1Input) return;
    const keyword1 = this.keyword1Input.value.trim();
    const keyword2 = this.keyword2Input?.value.trim() || "";
    const password = this.passwordInput?.value.trim() || null;
    if (!keyword1) {
      new import_obsidian2.Notice("Please enter keyword1");
      return;
    }
    const shortCode = keyword2 ? `${keyword1}/${keyword2}` : keyword1;
    if (!/^[a-zA-Z0-9가-힣_-]+$/.test(keyword1)) {
      new import_obsidian2.Notice("Keyword1 can only contain letters, numbers, Korean, _, and -");
      return;
    }
    if (keyword2 && !/^[a-zA-Z0-9가-힣_-]+$/.test(keyword2)) {
      new import_obsidian2.Notice("Keyword2 can only contain letters, numbers, Korean, _, and -");
      return;
    }
    try {
      this.progressEl?.show();
      this.resultEl?.hide();
      if (this.mainContent) this.mainContent.hide();
      this.updateProgress("\u{1F510} Authenticating...", 10);
      if (!this.authManager.isAuthenticated()) {
        throw new Error("Not authenticated. Please configure your email in settings.");
      }
      this.updateProgress("\u{1F4C4} Extracting markdown content...", 30);
      const extractor = new MarkdownExtractor(this.app, this.app.vault);
      const extracted = await extractor.extractMarkdown(this.file);
      console.log(`\u{1F4CA} Extracted: ${extracted.images.length} images, ${extracted.internalLinks.length} internal links`);
      if (extracted.images.length > 0) {
        console.log("\u{1F4F7} Image details:");
        extracted.images.forEach((img, idx) => {
          console.log(`  ${idx + 1}. ${img.name} (${(img.size / 1024).toFixed(1)}KB, ${img.mimeType})`);
          console.log(`     Original path: ${img.originalPath}`);
        });
      }
      this.updateProgress("\u{1F4DD} Creating memo...", 50);
      const memoUploader = new MemoUploader();
      const { memoId } = await memoUploader.createMemo(shortCode, password);
      let updatedContent = extracted.content;
      if (extracted.images.length > 0) {
        this.updateProgress(`\u{1F4E4} Uploading ${extracted.images.length} image(s)...`, 70);
        console.log("\u{1F511} User authenticated:", this.authManager.isAuthenticated());
        console.log("\u{1F464} Current user:", this.authManager.getCurrentUserEmail());
        const imageUploader = new ImageUploader();
        const uploadedImages = await imageUploader.uploadImages(extracted.images, memoId);
        updatedContent = imageUploader.replaceImagePaths(
          extracted.content,
          extracted.images,
          uploadedImages
        );
      }
      this.updateProgress("\u{1F4BE} Saving memo...", 90);
      await memoUploader.saveMemo(
        memoId,
        shortCode,
        updatedContent,
        extracted.images.length > 0 ? [] : [],
        // Images are already in content as URLs
        extracted.internalLinks,
        0,
        password
      );
      this.updateProgress("\u2705 Upload complete!", 100);
      const displayUrl = `https://uuu.gl/${shortCode}`;
      this.plugin.setUuuglUrl(this.file, displayUrl);
      await this.plugin.saveUrlCache();
      await this.plugin.updateStatusBar();
      this.showSuccess(displayUrl, "Note uploaded successfully!");
    } catch (error) {
      console.error("\u274C Upload failed:", error);
      this.showError(error.message || "Upload failed");
      if (this.mainContent) this.mainContent.show();
    }
  }
  updateProgress(message, percentage) {
    if (this.progressText) {
      this.progressText.setText(message);
    }
    if (this.progressBar && percentage !== void 0) {
      this.progressBar.style.width = `${percentage}%`;
    }
  }
  showSuccess(url, message = "Upload successful!") {
    if (!this.resultEl) return;
    this.progressEl?.hide();
    this.resultEl.empty();
    this.resultEl.show();
    this.resultEl.addClass("uuugl-success-container");
    const successHeader = this.resultEl.createDiv({ cls: "uuugl-success-header" });
    successHeader.createEl("div", {
      text: `\u2705 ${message}`,
      cls: "uuugl-success-title"
    });
    const urlSection = this.resultEl.createDiv({ cls: "uuugl-success-url-section" });
    urlSection.createEl("p", {
      text: "Your note is now live at:",
      cls: "uuugl-success-label"
    });
    const link = urlSection.createEl("a", {
      text: url,
      href: url,
      cls: "uuugl-success-url"
    });
    link.setAttribute("target", "_blank");
    const buttonContainer = this.resultEl.createDiv({ cls: "uuugl-success-buttons" });
    const copyButton = buttonContainer.createEl("button", {
      text: "Copy Link",
      cls: "uuugl-btn uuugl-btn-primary"
    });
    copyButton.addEventListener("click", () => {
      navigator.clipboard.writeText(url);
      new import_obsidian2.Notice("Link copied to clipboard!");
    });
    const closeButton = buttonContainer.createEl("button", {
      text: "Close",
      cls: "uuugl-btn uuugl-btn-secondary"
    });
    closeButton.addEventListener("click", () => this.close());
    new import_obsidian2.Notice(`\u2705 ${message}`);
  }
  showError(message) {
    if (!this.resultEl) return;
    this.progressEl?.hide();
    if (this.mainContent) this.mainContent.hide();
    this.resultEl.empty();
    this.resultEl.show();
    this.resultEl.createEl("div", {
      text: `\u274C Failed: ${message}`,
      cls: "upload-modal-error"
    });
    const closeButton = this.resultEl.createEl("button", {
      text: "Close"
    });
    closeButton.addEventListener("click", () => this.close());
    new import_obsidian2.Notice(`\u274C Failed: ${message}`);
  }
  sanitizeShortCode(name6) {
    return name6.toLowerCase().replace(/[^a-zA-Z0-9가-힣-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
  }
  generateRandomShortCode() {
    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
    let result = "";
    for (let i = 0; i < 8; i++) {
      result += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return result;
  }
};

// src/settings.ts
var import_obsidian3 = require("obsidian");
var DEFAULT_SETTINGS = {
  email: "",
  uid: "",
  fingerprint: "",
  lastSyncedAt: "",
  defaultShortCodePrefix: "obsidian",
  urlCache: {}
  // Persistent URL cache
};
var UuuglSettingTab = class extends import_obsidian3.PluginSettingTab {
  constructor(app2, plugin) {
    super(app2, plugin);
    this.plugin = plugin;
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    containerEl.createEl("h2", { text: "uuu.gl Markdown Uploader Settings" });
    containerEl.createEl("p", {
      text: "Upload your Obsidian notes to uuu.gl as beautifully rendered Markdown documents.",
      cls: "setting-item-description"
    });
    containerEl.createEl("h3", { text: "Authentication" });
    const currentUser = this.plugin.authManager.getCurrentUser();
    if (currentUser) {
      new import_obsidian3.Setting(containerEl).setName("Logged in as").setDesc(currentUser.email || "No email").addButton(
        (button) => button.setButtonText("Sign Out").onClick(async () => {
          await this.plugin.authManager.signOut();
          this.plugin.settings.email = "";
          this.plugin.settings.uid = "";
          await this.plugin.saveSettings();
          this.display();
        })
      );
    } else {
      new import_obsidian3.Setting(containerEl).setName("Google Sign In").setDesc("Sign in with your Google account to upload notes").addButton(
        (button) => button.setButtonText("Sign In with Google").setCta().onClick(async () => {
          try {
            button.setDisabled(true);
            button.setButtonText("Signing in...");
            const user = await this.plugin.authManager.signInWithGoogle();
            if (user.email && user.uid) {
              this.plugin.settings.email = user.email;
              this.plugin.settings.uid = user.uid;
              await this.plugin.saveSettings();
            }
            this.display();
          } catch (error) {
            console.error("Sign in failed:", error);
            new import_obsidian3.Notice(`\u274C Sign in failed: ${error.message}`);
            button.setDisabled(false);
            button.setButtonText("Sign In with Google");
          }
        })
      );
    }
    if (currentUser) {
      containerEl.createEl("h3", { text: "Storage Usage" });
      const storageContainer = containerEl.createDiv({ cls: "storage-usage-container" });
      storageContainer.createEl("p", { text: "Loading storage information..." });
      this.fetchStorageStats(storageContainer);
    }
    new import_obsidian3.Setting(containerEl).setName("Default ShortCode Prefix").setDesc('Prefix for auto-generated shortcodes (e.g., "obsidian/my-note")').addText(
      (text) => text.setPlaceholder("obsidian").setValue(this.plugin.settings.defaultShortCodePrefix).onChange(async (value) => {
        this.plugin.settings.defaultShortCodePrefix = value;
        await this.plugin.saveSettings();
      })
    );
    new import_obsidian3.Setting(containerEl).setName("Device Fingerprint").setDesc("Unique identifier for this device (auto-generated)").addText(
      (text) => text.setValue(this.plugin.settings.fingerprint || "Not generated yet").setDisabled(true)
    );
    if (this.plugin.settings.lastSyncedAt) {
      new import_obsidian3.Setting(containerEl).setName("Last Upload").setDesc("When you last uploaded a note").addText(
        (text) => text.setValue(new Date(this.plugin.settings.lastSyncedAt).toLocaleString()).setDisabled(true)
      );
    }
    containerEl.createEl("hr");
    containerEl.createEl("h3", { text: "How to Use" });
    const instructionsList = containerEl.createEl("ol");
    instructionsList.createEl("li", { text: "Enter your email address above" });
    instructionsList.createEl("li", { text: "Open any note in Obsidian" });
    instructionsList.createEl("li", { text: "Click the upload icon in the ribbon or use the command palette" });
    instructionsList.createEl("li", { text: "Choose a shortcode (URL path) for your note" });
    instructionsList.createEl("li", { text: "Your note will be uploaded with all images and internal links preserved!" });
    containerEl.createEl("p", {
      text: "Need help? Visit "
    }).createEl("a", {
      text: "uuu.gl",
      href: "https://uuu.gl"
    });
  }
  /**
   * Fetch and display storage statistics
   */
  async fetchStorageStats(container) {
    try {
      const token = await this.plugin.authManager.getIdToken();
      const { functions: functions2 } = await Promise.resolve().then(() => (init_firebase_config(), firebase_config_exports));
      const { httpsCallable: httpsCallable2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
      const getUserStats = httpsCallable2(functions2, "getUserStats");
      const result = await getUserStats({});
      const stats = result.data;
      container.empty();
      const formatBytes = (bytes) => {
        if (bytes === 0) return "0 B";
        const k = 1024;
        const sizes = ["B", "KB", "MB", "GB"];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
      };
      const usedBytes = stats.storageUsed || 0;
      const limitBytes = stats.storageLimit || 0;
      const usedFormatted = formatBytes(usedBytes);
      const limitFormatted = limitBytes === -1 ? "Unlimited" : formatBytes(limitBytes);
      const percentage = limitBytes === -1 ? 0 : Math.min(100, usedBytes / limitBytes * 100);
      new import_obsidian3.Setting(container).setName("Storage Used").setDesc(`${usedFormatted} / ${limitFormatted}`).setClass("storage-stat");
      const progressContainer = container.createDiv({ cls: "storage-progress" });
      progressContainer.createEl("div", {
        cls: "storage-progress-bar",
        attr: {
          style: `width: ${percentage}%; background-color: ${percentage > 90 ? "#ef4444" : percentage > 70 ? "#f59e0b" : "#22c55e"}`
        }
      });
      new import_obsidian3.Setting(container).setName("Total URLs").setDesc(`${stats.urlCount || 0} URLs created`);
      new import_obsidian3.Setting(container).setName("Total Files").setDesc(`${stats.fileCount || 0} files uploaded`);
      new import_obsidian3.Setting(container).setName("Total Clicks").setDesc(`${stats.totalClicks || 0} clicks on your URLs`);
      if (!document.getElementById("uuugl-storage-styles")) {
        const style = document.createElement("style");
        style.id = "uuugl-storage-styles";
        style.textContent = `
          .storage-progress {
            width: 100%;
            height: 8px;
            background-color: var(--background-modifier-border);
            border-radius: 4px;
            overflow: hidden;
            margin: 10px 0;
          }
          .storage-progress-bar {
            height: 100%;
            transition: width 0.3s ease;
            border-radius: 4px;
          }
          .storage-usage-container {
            padding: 10px 0;
          }
        `;
        document.head.appendChild(style);
      }
    } catch (error) {
      console.error("Failed to fetch storage stats:", error);
      container.empty();
      container.createEl("p", {
        text: "Failed to load storage information",
        cls: "mod-warning"
      });
    }
  }
};

// src/main.ts
var import_fingerprintjs = __toESM(require_fp_cjs());
var UuuglPlugin = class extends import_obsidian4.Plugin {
  constructor() {
    super(...arguments);
    this.settings = DEFAULT_SETTINGS;
    this.authManager = new AuthManager();
    this.fingerprint = "";
    this.statusBarItem = null;
    // Memory-based URL storage (file path -> uuu.gl URL)
    this.urlCache = /* @__PURE__ */ new Map();
  }
  async onload() {
    console.log("\u2705 Loading uuu.gl Markdown Uploader plugin");
    await this.loadSettings();
    this.restoreUrlCacheFromSettings();
    await this.initializeFingerprint();
    this.autoReauthenticate().catch((err) => {
      console.error("\u274C Background re-authentication failed:", err);
    });
    this.monitorAuthState();
    this.addSettingTab(new UuuglSettingTab(this.app, this));
    this.initializeUrlCache().catch((err) => {
      console.error("\u274C Failed to initialize URL cache:", err);
    });
    this.statusBarItem = this.addStatusBarItem();
    this.statusBarItem.addClass("uuugl-status-bar");
    this.registerEvent(
      this.app.workspace.on("active-leaf-change", () => {
        this.updateStatusBar();
      })
    );
    this.registerEvent(
      this.app.vault.on("modify", (file) => {
        const activeFile = this.app.workspace.getActiveFile();
        if (file === activeFile) {
          this.updateStatusBar();
        }
      })
    );
    this.registerObsidianProtocolHandler("uuugl-uploader", (params) => {
      console.log("\u{1F517} Received obsidian:// URL:", params);
      const uri = `obsidian://uuugl-uploader${params.action ? "/" + params.action : ""}?${new URLSearchParams(params).toString()}`;
      const handled = this.authManager.handleCallback(uri);
      if (handled) {
        console.log("\u2705 Auth callback handled successfully");
      }
    });
    this.addRibbonIcon("upload-cloud", "Upload note to uuu.gl", async () => {
      await this.handleUploadCommand();
    });
    this.addCommand({
      id: "upload-markdown",
      name: "Upload current note to uuu.gl",
      checkCallback: (checking) => {
        const activeFile = this.app.workspace.getActiveFile();
        if (activeFile) {
          if (!checking) {
            this.handleUploadCommand();
          }
          return true;
        }
        return false;
      }
    });
    this.addCommand({
      id: "upload-markdown-custom",
      name: "Upload current note with custom shortcode",
      checkCallback: (checking) => {
        const activeFile = this.app.workspace.getActiveFile();
        if (activeFile) {
          if (!checking) {
            this.openUploadModal(activeFile);
          }
          return true;
        }
        return false;
      }
    });
    this.addCommand({
      id: "copy-uuugl-link",
      name: "Copy uuu.gl link",
      checkCallback: (checking) => {
        const activeFile = this.app.workspace.getActiveFile();
        if (activeFile) {
          const url = this.getUuuglLinkFromFile(activeFile);
          if (url) {
            if (!checking) {
              navigator.clipboard.writeText(url);
              new import_obsidian4.Notice("\u{1F4CE} uuu.gl link copied to clipboard!");
            }
            return true;
          }
        }
        return false;
      }
    });
    console.log("\u2705 uuu.gl plugin loaded successfully");
  }
  async onunload() {
    console.log("Unloading uuu.gl plugin");
  }
  async loadSettings() {
    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
  }
  async saveSettings() {
    await this.saveData(this.settings);
  }
  /**
   * Restore URL cache from persistent settings storage
   */
  restoreUrlCacheFromSettings() {
    if (this.settings.urlCache && typeof this.settings.urlCache === "object") {
      for (const [filePath, url] of Object.entries(this.settings.urlCache)) {
        this.urlCache.set(filePath, url);
      }
      console.log(`\u2705 Restored ${this.urlCache.size} URLs from persistent storage`);
    }
  }
  /**
   * Initialize URL cache by scanning all markdown files for uuugl frontmatter
   * (Legacy support - for frontmatter-based storage)
   */
  async initializeUrlCache() {
    try {
      console.log("\u{1F504} Initializing URL cache from frontmatter...");
      const files = this.app.vault.getMarkdownFiles();
      let cachedCount = 0;
      for (const file of files) {
        try {
          const content = await this.app.vault.read(file);
          const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
          const match = content.match(frontmatterRegex);
          if (!match) continue;
          const frontmatter = match[1];
          const lines = frontmatter.split("\n");
          for (const line of lines) {
            if (line.startsWith("uuugl:")) {
              const url = line.replace("uuugl:", "").trim();
              if (url) {
                this.urlCache.set(file.path, url);
                cachedCount++;
                break;
              }
            }
          }
        } catch (error) {
          continue;
        }
      }
      console.log(`\u2705 URL cache initialized: ${cachedCount} links found`);
      await this.updateStatusBar();
    } catch (error) {
      console.error("\u274C Failed to initialize URL cache:", error);
    }
  }
  /**
   * Initialize device fingerprint for rate limiting
   */
  async initializeFingerprint() {
    if (this.settings.fingerprint) {
      this.fingerprint = this.settings.fingerprint;
      console.log("\u{1F511} Loaded existing fingerprint");
      return;
    }
    try {
      const fp = await import_fingerprintjs.default.load();
      const result = await fp.get();
      this.fingerprint = result.visitorId;
      this.settings.fingerprint = this.fingerprint;
      await this.saveSettings();
      console.log("\u{1F511} Fingerprint generated:", this.fingerprint);
    } catch (error) {
      console.error("\u274C Failed to generate fingerprint:", error);
      this.fingerprint = `obsidian-${Date.now()}`;
      this.settings.fingerprint = this.fingerprint;
      await this.saveSettings();
    }
  }
  /**
   * Auto re-authenticate using saved credentials
   */
  async autoReauthenticate() {
    if (this.authManager.isAuthenticated()) {
      console.log("\u2705 Already authenticated");
      return;
    }
    if (this.settings.email && this.settings.uid) {
      try {
        console.log("\u{1F504} Attempting auto re-authentication for:", this.settings.email);
        const { functions: functions2 } = await Promise.resolve().then(() => (init_firebase_config(), firebase_config_exports));
        const { httpsCallable: httpsCallable2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
        const generateCustomToken = httpsCallable2(functions2, "generateCustomToken");
        const result = await generateCustomToken({ email: this.settings.email });
        const { customToken } = result.data;
        const { auth: auth2 } = await Promise.resolve().then(() => (init_firebase_config(), firebase_config_exports));
        const { signInWithCustomToken: signInWithCustomToken2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
        await signInWithCustomToken2(auth2, customToken);
        console.log("\u2705 Auto re-authentication successful");
      } catch (error) {
        console.error("\u274C Auto re-authentication failed:", error);
        this.settings.email = "";
        this.settings.uid = "";
        await this.saveSettings();
      }
    }
  }
  /**
   * Handle upload command
   */
  async handleUploadCommand() {
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      new import_obsidian4.Notice("No active file to upload");
      return;
    }
    try {
      if (!this.authManager.isAuthenticated()) {
        new import_obsidian4.Notice("\u{1F510} Signing in with Google...");
        const user = await this.authManager.signInWithGoogle();
        if (user.email && user.uid) {
          this.settings.email = user.email;
          this.settings.uid = user.uid;
          await this.saveSettings();
        }
        new import_obsidian4.Notice(`\u2705 Welcome, ${user.email || "User"}!`);
      }
      this.openUploadModal(activeFile);
    } catch (error) {
      console.error("\u274C Authentication failed:", error);
      new import_obsidian4.Notice(`\u274C Authentication failed: ${error.message}`);
    }
  }
  /**
   * Monitor Firebase authentication state
   */
  monitorAuthState() {
    const { auth: auth2 } = (init_firebase_config(), __toCommonJS(firebase_config_exports));
    const { onAuthStateChanged: onAuthStateChanged2 } = require_index_cjs4();
    onAuthStateChanged2(auth2, (user) => {
      if (user) {
        console.log("\u2705 User authenticated:", user.email);
        if (user.email && user.uid) {
          if (this.settings.email !== user.email || this.settings.uid !== user.uid) {
            this.settings.email = user.email;
            this.settings.uid = user.uid;
            this.saveSettings();
          }
        }
      } else {
        console.log("\u2139\uFE0F No user authenticated");
      }
    });
  }
  /**
   * Open upload modal
   */
  openUploadModal(file) {
    const modal = new UploadModal(
      this.app,
      file,
      this.authManager,
      this,
      // Pass plugin instance
      this.settings.defaultShortCodePrefix
    );
    modal.open();
  }
  /**
   * Update status bar with current file's uuu.gl link
   */
  async updateStatusBar() {
    if (!this.statusBarItem) return;
    const activeFile = this.app.workspace.getActiveFile();
    if (!activeFile) {
      this.statusBarItem.setText("");
      return;
    }
    const url = await this.getUuuglLinkFromFile(activeFile);
    if (url) {
      const shortCode = url.replace("https://uuu.gl/", "");
      this.statusBarItem.setText(`\u{1F517} ${shortCode}`);
      this.statusBarItem.setAttribute("title", `Click to copy: ${url}`);
      this.statusBarItem.onclick = () => {
        navigator.clipboard.writeText(url);
        new import_obsidian4.Notice("\u{1F4CE} uuu.gl link copied to clipboard!");
      };
      this.statusBarItem.style.cursor = "pointer";
    } else {
      this.statusBarItem.setText("");
      this.statusBarItem.onclick = null;
      this.statusBarItem.style.cursor = "default";
    }
  }
  /**
   * Get uuu.gl link from memory cache or file's frontmatter
   */
  async getUuuglLinkFromFile(file) {
    try {
      const cachedUrl = this.urlCache.get(file.path);
      if (cachedUrl) {
        return cachedUrl;
      }
      const content = await this.app.vault.read(file);
      const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
      const match = content.match(frontmatterRegex);
      if (!match) return null;
      const frontmatter = match[1];
      const lines = frontmatter.split("\n");
      for (const line of lines) {
        if (line.startsWith("uuugl:")) {
          const url = line.replace("uuugl:", "").trim();
          if (url) {
            this.urlCache.set(file.path, url);
            return url;
          }
        }
      }
      return null;
    } catch (error) {
      console.error("Failed to read uuu.gl link:", error);
      return null;
    }
  }
  /**
   * Set uuu.gl URL for a file (in memory cache only)
   */
  setUuuglUrl(file, url) {
    this.urlCache.set(file.path, url);
  }
  /**
   * Remove uuu.gl URL from cache
   */
  removeUuuglUrl(file) {
    this.urlCache.delete(file.path);
  }
  /**
   * Save URL cache to persistent settings storage
   */
  async saveUrlCache() {
    const cacheObject = {};
    for (const [filePath, url] of this.urlCache.entries()) {
      cacheObject[filePath] = url;
    }
    this.settings.urlCache = cacheObject;
    await this.saveSettings();
    console.log(`\u{1F4BE} Saved ${this.urlCache.size} URLs to persistent storage`);
  }
};
/*! Bundled license information:

@firebase/util/dist/node-esm/index.node.esm.js:
@firebase/util/dist/index.node.cjs.js:
  (**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @license
   * Copyright 2022 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @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.
   *)
  (**
   * @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.
   *)
  (**
   * @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.
   *)
  (**
   * @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.
   *)

@firebase/component/dist/esm/index.esm.js:
@firebase/component/dist/index.cjs.js:
  (**
   * @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.
   *)

@firebase/logger/dist/esm/index.esm.js:
@firebase/logger/dist/index.cjs.js:
  (**
   * @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.
   *)

@firebase/app/dist/esm/index.esm.js:
@firebase/app/dist/index.cjs.js:
  (**
   * @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.
   *)
  (**
   * @license
   * Copyright 2023 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @license
   * Copyright 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.
   *)

firebase/app/dist/index.mjs:
  (**
   * @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.
   *)

@firebase/auth/dist/node-esm/totp-c8d207b9.js:
@firebase/auth/dist/node/totp-50d5d5dd.js:
  (**
   * @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.
   *)
  (**
   * @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.
   *)
  (**
   * @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.
   *)
  (**
   * @license
   * Copyright 2022 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @license
   * Copyright 2023 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.
   *)

@firebase/functions/dist/esm/index.esm.js:
  (**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @license
   * Copyright 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.
   *)
  (**
   * @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.
   *)

@firebase/storage/dist/node-esm/index.node.esm.js:
  (**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @license
   * Copyright 2022 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)
  (**
   * @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.
   *)
  (**
   * @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.
   *)
  (**
   * @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.
   *)
*/
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["node_modules/@firebase/util/dist/postinstall.mjs", "node_modules/@firebase/util/src/constants.ts", "node_modules/@firebase/util/src/assert.ts", "node_modules/@firebase/util/src/crypt.ts", "node_modules/@firebase/util/src/deepCopy.ts", "node_modules/@firebase/util/src/global.ts", "node_modules/@firebase/util/src/defaults.ts", "node_modules/@firebase/util/src/deferred.ts", "node_modules/@firebase/util/src/url.ts", "node_modules/@firebase/util/src/emulator.ts", "node_modules/@firebase/util/src/environment.ts", "node_modules/@firebase/util/src/errors.ts", "node_modules/@firebase/util/src/json.ts", "node_modules/@firebase/util/src/jwt.ts", "node_modules/@firebase/util/src/obj.ts", "node_modules/@firebase/util/src/promise.ts", "node_modules/@firebase/util/src/query.ts", "node_modules/@firebase/util/src/sha1.ts", "node_modules/@firebase/util/src/subscribe.ts", "node_modules/@firebase/util/src/validation.ts", "node_modules/@firebase/util/src/utf8.ts", "node_modules/@firebase/util/src/exponential_backoff.ts", "node_modules/@firebase/util/src/formatters.ts", "node_modules/@firebase/util/src/compat.ts", "node_modules/@firebase/util/index.node.ts", "node_modules/@firebase/component/src/component.ts", "node_modules/@firebase/component/src/constants.ts", "node_modules/@firebase/component/src/provider.ts", "node_modules/@firebase/component/src/component_container.ts", "node_modules/@firebase/logger/src/logger.ts", "node_modules/idb/build/wrap-idb-value.js", "node_modules/idb/build/index.js", "node_modules/@firebase/app/src/platformLoggerService.ts", "node_modules/@firebase/app/src/logger.ts", "node_modules/@firebase/app/src/constants.ts", "node_modules/@firebase/app/src/internal.ts", "node_modules/@firebase/app/src/errors.ts", "node_modules/@firebase/app/src/firebaseApp.ts", "node_modules/@firebase/app/src/firebaseServerApp.ts", "node_modules/@firebase/app/src/api.ts", "node_modules/@firebase/app/src/indexeddb.ts", "node_modules/@firebase/app/src/heartbeatService.ts", "node_modules/@firebase/app/src/registerCoreComponents.ts", "node_modules/@firebase/app/src/index.ts", "node_modules/firebase/app/index.ts", "node_modules/@firebase/auth/src/model/enum_maps.ts", "node_modules/@firebase/auth/src/core/errors.ts", "node_modules/@firebase/auth/src/core/util/log.ts", "node_modules/@firebase/auth/src/core/util/assert.ts", "node_modules/@firebase/auth/src/core/util/location.ts", "node_modules/@firebase/auth/src/core/util/navigator.ts", "node_modules/@firebase/auth/src/core/util/delay.ts", "node_modules/@firebase/auth/src/core/util/emulator.ts", "node_modules/@firebase/auth/src/core/util/fetch_provider.ts", "node_modules/@firebase/auth/src/api/errors.ts", "node_modules/@firebase/auth/src/api/index.ts", "node_modules/@firebase/auth/src/platform_browser/recaptcha/recaptcha.ts", "node_modules/@firebase/auth/src/api/authentication/recaptcha.ts", "node_modules/@firebase/auth/src/api/account_management/account.ts", "node_modules/@firebase/auth/src/core/util/time.ts", "node_modules/@firebase/auth/src/core/user/id_token_result.ts", "node_modules/@firebase/auth/src/core/user/invalidation.ts", "node_modules/@firebase/auth/src/core/user/proactive_refresh.ts", "node_modules/@firebase/auth/src/core/user/user_metadata.ts", "node_modules/@firebase/auth/src/core/user/reload.ts", "node_modules/@firebase/auth/src/api/authentication/token.ts", "node_modules/@firebase/auth/src/core/user/token_manager.ts", "node_modules/@firebase/auth/src/core/user/user_impl.ts", "node_modules/@firebase/auth/src/core/util/instantiator.ts", "node_modules/@firebase/auth/src/core/persistence/in_memory.ts", "node_modules/@firebase/auth/src/core/persistence/persistence_user_manager.ts", "node_modules/@firebase/auth/src/core/util/browser.ts", "node_modules/@firebase/auth/src/core/util/version.ts", "node_modules/@firebase/auth/src/core/auth/middleware.ts", "node_modules/@firebase/auth/src/api/password_policy/get_password_policy.ts", "node_modules/@firebase/auth/src/core/auth/password_policy_impl.ts", "node_modules/@firebase/auth/src/core/auth/auth_impl.ts", "node_modules/@firebase/auth/src/platform_browser/load_js.ts", "node_modules/@firebase/auth/src/platform_browser/recaptcha/recaptcha_mock.ts", "node_modules/@firebase/auth/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.ts", "node_modules/@firebase/auth/src/core/auth/initialize.ts", "node_modules/@firebase/auth/src/core/auth/emulator.ts", "node_modules/@firebase/auth/src/core/credentials/auth_credential.ts", "node_modules/@firebase/auth/src/api/account_management/email_and_password.ts", "node_modules/@firebase/auth/src/api/authentication/email_and_password.ts", "node_modules/@firebase/auth/src/api/authentication/email_link.ts", "node_modules/@firebase/auth/src/core/credentials/email.ts", "node_modules/@firebase/auth/src/api/authentication/idp.ts", "node_modules/@firebase/auth/src/core/credentials/oauth.ts", "node_modules/@firebase/auth/src/api/authentication/sms.ts", "node_modules/@firebase/auth/src/core/credentials/phone.ts", "node_modules/@firebase/auth/src/core/action_code_url.ts", "node_modules/@firebase/auth/src/core/providers/email.ts", "node_modules/@firebase/auth/src/core/providers/federated.ts", "node_modules/@firebase/auth/src/core/providers/oauth.ts", "node_modules/@firebase/auth/src/core/providers/facebook.ts", "node_modules/@firebase/auth/src/core/providers/google.ts", "node_modules/@firebase/auth/src/core/providers/github.ts", "node_modules/@firebase/auth/src/core/credentials/saml.ts", "node_modules/@firebase/auth/src/core/providers/saml.ts", "node_modules/@firebase/auth/src/core/providers/twitter.ts", "node_modules/@firebase/auth/src/api/authentication/sign_up.ts", "node_modules/@firebase/auth/src/core/user/user_credential_impl.ts", "node_modules/@firebase/auth/src/core/strategies/anonymous.ts", "node_modules/@firebase/auth/src/mfa/mfa_error.ts", "node_modules/@firebase/auth/src/core/util/providers.ts", "node_modules/@firebase/auth/src/core/user/link_unlink.ts", "node_modules/@firebase/auth/src/core/user/reauthenticate.ts", "node_modules/@firebase/auth/src/core/strategies/credential.ts", "node_modules/@firebase/auth/src/api/authentication/custom_token.ts", "node_modules/@firebase/auth/src/core/strategies/custom_token.ts", "node_modules/@firebase/auth/src/mfa/mfa_info.ts", "node_modules/@firebase/auth/src/core/strategies/action_code_settings.ts", "node_modules/@firebase/auth/src/core/strategies/email_and_password.ts", "node_modules/@firebase/auth/src/core/strategies/email_link.ts", "node_modules/@firebase/auth/src/api/authentication/create_auth_uri.ts", "node_modules/@firebase/auth/src/core/strategies/email.ts", "node_modules/@firebase/auth/src/api/account_management/profile.ts", "node_modules/@firebase/auth/src/core/user/account_info.ts", "node_modules/@firebase/auth/src/core/user/additional_user_info.ts", "node_modules/@firebase/auth/src/core/index.ts", "node_modules/@firebase/auth/src/mfa/mfa_session.ts", "node_modules/@firebase/auth/src/mfa/mfa_resolver.ts", "node_modules/@firebase/auth/src/api/account_management/mfa.ts", "node_modules/@firebase/auth/src/mfa/mfa_user.ts", "node_modules/@firebase/auth/src/core/auth/firebase_internal.ts", "node_modules/@firebase/auth/src/core/auth/register.ts", "node_modules/@firebase/auth/src/platform_node/index.ts", "node_modules/@firebase/auth/src/api/authentication/mfa.ts", "node_modules/@firebase/auth/src/mfa/mfa_assertion.ts", "node_modules/@firebase/auth/src/mfa/assertions/totp.ts", "node_modules/@firebase/auth/dist/node-esm/index.js", "node_modules/firebase/auth/dist/index.mjs", "node_modules/@firebase/functions/src/serializer.ts", "node_modules/@firebase/functions/src/constants.ts", "node_modules/@firebase/functions/src/error.ts", "node_modules/@firebase/functions/src/context.ts", "node_modules/@firebase/functions/src/service.ts", "node_modules/@firebase/functions/src/config.ts", "node_modules/@firebase/functions/src/api.ts", "node_modules/@firebase/functions/src/index.ts", "node_modules/firebase/functions/dist/index.mjs", "node_modules/@firebase/storage/src/implementation/constants.ts", "node_modules/@firebase/storage/src/implementation/error.ts", "node_modules/@firebase/storage/src/implementation/location.ts", "node_modules/@firebase/storage/src/implementation/failrequest.ts", "node_modules/@firebase/storage/src/implementation/backoff.ts", "node_modules/@firebase/storage/src/implementation/type.ts", "node_modules/@firebase/storage/src/implementation/url.ts", "node_modules/@firebase/storage/src/implementation/connection.ts", "node_modules/@firebase/storage/src/implementation/utils.ts", "node_modules/@firebase/storage/src/implementation/request.ts", "node_modules/@firebase/storage/src/implementation/fs.ts", "node_modules/@firebase/storage/src/platform/node/base64.ts", "node_modules/@firebase/storage/src/implementation/string.ts", "node_modules/@firebase/storage/src/implementation/blob.ts", "node_modules/@firebase/storage/src/implementation/json.ts", "node_modules/@firebase/storage/src/implementation/path.ts", "node_modules/@firebase/storage/src/implementation/metadata.ts", "node_modules/@firebase/storage/src/implementation/list.ts", "node_modules/@firebase/storage/src/implementation/requestinfo.ts", "node_modules/@firebase/storage/src/implementation/requests.ts", "node_modules/@firebase/storage/src/implementation/taskenums.ts", "node_modules/@firebase/storage/src/implementation/observer.ts", "node_modules/@firebase/storage/src/implementation/async.ts", "node_modules/@firebase/storage/src/platform/node/connection.ts", "node_modules/@firebase/storage/src/task.ts", "node_modules/@firebase/storage/src/reference.ts", "node_modules/@firebase/storage/src/service.ts", "node_modules/@firebase/storage/src/constants.ts", "node_modules/@firebase/storage/src/api.ts", "node_modules/@firebase/storage/src/api.node.ts", "node_modules/@firebase/storage/src/index.node.ts", "node_modules/firebase/storage/dist/index.mjs", "src/firebase-config.ts", "node_modules/@fingerprintjs/fingerprintjs/dist/fp.cjs.js", "node_modules/@firebase/util/dist/postinstall.js", "node_modules/@firebase/util/src/constants.ts", "node_modules/@firebase/util/src/assert.ts", "node_modules/@firebase/util/src/crypt.ts", "node_modules/@firebase/util/src/deepCopy.ts", "node_modules/@firebase/util/src/global.ts", "node_modules/@firebase/util/src/defaults.ts", "node_modules/@firebase/util/src/deferred.ts", "node_modules/@firebase/util/src/url.ts", "node_modules/@firebase/util/src/emulator.ts", "node_modules/@firebase/util/src/environment.ts", "node_modules/@firebase/util/src/errors.ts", "node_modules/@firebase/util/src/json.ts", "node_modules/@firebase/util/src/jwt.ts", "node_modules/@firebase/util/src/obj.ts", "node_modules/@firebase/util/src/promise.ts", "node_modules/@firebase/util/src/query.ts", "node_modules/@firebase/util/src/sha1.ts", "node_modules/@firebase/util/src/subscribe.ts", "node_modules/@firebase/util/src/validation.ts", "node_modules/@firebase/util/src/utf8.ts", "node_modules/@firebase/util/src/exponential_backoff.ts", "node_modules/@firebase/util/src/formatters.ts", "node_modules/@firebase/util/src/compat.ts", "node_modules/@firebase/util/index.node.ts", "node_modules/@firebase/component/src/component.ts", "node_modules/@firebase/component/src/constants.ts", "node_modules/@firebase/component/src/provider.ts", "node_modules/@firebase/component/src/component_container.ts", "node_modules/@firebase/logger/src/logger.ts", "node_modules/@firebase/app/src/platformLoggerService.ts", "node_modules/@firebase/app/src/logger.ts", "node_modules/@firebase/app/src/constants.ts", "node_modules/@firebase/app/src/internal.ts", "node_modules/@firebase/app/src/errors.ts", "node_modules/@firebase/app/src/firebaseApp.ts", "node_modules/@firebase/app/src/firebaseServerApp.ts", "node_modules/@firebase/app/src/api.ts", "node_modules/@firebase/app/src/indexeddb.ts", "node_modules/@firebase/app/src/heartbeatService.ts", "node_modules/@firebase/app/src/registerCoreComponents.ts", "node_modules/@firebase/app/src/index.ts", "node_modules/@firebase/auth/src/model/enum_maps.ts", "node_modules/@firebase/auth/src/core/errors.ts", "node_modules/@firebase/auth/src/core/util/log.ts", "node_modules/@firebase/auth/src/core/util/assert.ts", "node_modules/@firebase/auth/src/core/util/location.ts", "node_modules/@firebase/auth/src/core/util/navigator.ts", "node_modules/@firebase/auth/src/core/util/delay.ts", "node_modules/@firebase/auth/src/core/util/emulator.ts", "node_modules/@firebase/auth/src/core/util/fetch_provider.ts", "node_modules/@firebase/auth/src/api/errors.ts", "node_modules/@firebase/auth/src/api/index.ts", "node_modules/@firebase/auth/src/platform_browser/recaptcha/recaptcha.ts", "node_modules/@firebase/auth/src/api/authentication/recaptcha.ts", "node_modules/@firebase/auth/src/api/account_management/account.ts", "node_modules/@firebase/auth/src/core/util/time.ts", "node_modules/@firebase/auth/src/core/user/id_token_result.ts", "node_modules/@firebase/auth/src/core/user/invalidation.ts", "node_modules/@firebase/auth/src/core/user/proactive_refresh.ts", "node_modules/@firebase/auth/src/core/user/user_metadata.ts", "node_modules/@firebase/auth/src/core/user/reload.ts", "node_modules/@firebase/auth/src/api/authentication/token.ts", "node_modules/@firebase/auth/src/core/user/token_manager.ts", "node_modules/@firebase/auth/src/core/user/user_impl.ts", "node_modules/@firebase/auth/src/core/util/instantiator.ts", "node_modules/@firebase/auth/src/core/persistence/in_memory.ts", "node_modules/@firebase/auth/src/core/persistence/persistence_user_manager.ts", "node_modules/@firebase/auth/src/core/util/browser.ts", "node_modules/@firebase/auth/src/core/util/version.ts", "node_modules/@firebase/auth/src/core/auth/middleware.ts", "node_modules/@firebase/auth/src/api/password_policy/get_password_policy.ts", "node_modules/@firebase/auth/src/core/auth/password_policy_impl.ts", "node_modules/@firebase/auth/src/core/auth/auth_impl.ts", "node_modules/@firebase/auth/src/platform_browser/load_js.ts", "node_modules/@firebase/auth/src/platform_browser/recaptcha/recaptcha_mock.ts", "node_modules/@firebase/auth/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.ts", "node_modules/@firebase/auth/src/core/auth/initialize.ts", "node_modules/@firebase/auth/src/core/auth/emulator.ts", "node_modules/@firebase/auth/src/core/credentials/auth_credential.ts", "node_modules/@firebase/auth/src/api/account_management/email_and_password.ts", "node_modules/@firebase/auth/src/api/authentication/email_and_password.ts", "node_modules/@firebase/auth/src/api/authentication/email_link.ts", "node_modules/@firebase/auth/src/core/credentials/email.ts", "node_modules/@firebase/auth/src/api/authentication/idp.ts", "node_modules/@firebase/auth/src/core/credentials/oauth.ts", "node_modules/@firebase/auth/src/api/authentication/sms.ts", "node_modules/@firebase/auth/src/core/credentials/phone.ts", "node_modules/@firebase/auth/src/core/action_code_url.ts", "node_modules/@firebase/auth/src/core/providers/email.ts", "node_modules/@firebase/auth/src/core/providers/federated.ts", "node_modules/@firebase/auth/src/core/providers/oauth.ts", "node_modules/@firebase/auth/src/core/providers/facebook.ts", "node_modules/@firebase/auth/src/core/providers/google.ts", "node_modules/@firebase/auth/src/core/providers/github.ts", "node_modules/@firebase/auth/src/core/credentials/saml.ts", "node_modules/@firebase/auth/src/core/providers/saml.ts", "node_modules/@firebase/auth/src/core/providers/twitter.ts", "node_modules/@firebase/auth/src/api/authentication/sign_up.ts", "node_modules/@firebase/auth/src/core/user/user_credential_impl.ts", "node_modules/@firebase/auth/src/core/strategies/anonymous.ts", "node_modules/@firebase/auth/src/mfa/mfa_error.ts", "node_modules/@firebase/auth/src/core/util/providers.ts", "node_modules/@firebase/auth/src/core/user/link_unlink.ts", "node_modules/@firebase/auth/src/core/user/reauthenticate.ts", "node_modules/@firebase/auth/src/core/strategies/credential.ts", "node_modules/@firebase/auth/src/api/authentication/custom_token.ts", "node_modules/@firebase/auth/src/core/strategies/custom_token.ts", "node_modules/@firebase/auth/src/mfa/mfa_info.ts", "node_modules/@firebase/auth/src/core/strategies/action_code_settings.ts", "node_modules/@firebase/auth/src/core/strategies/email_and_password.ts", "node_modules/@firebase/auth/src/core/strategies/email_link.ts", "node_modules/@firebase/auth/src/api/authentication/create_auth_uri.ts", "node_modules/@firebase/auth/src/core/strategies/email.ts", "node_modules/@firebase/auth/src/api/account_management/profile.ts", "node_modules/@firebase/auth/src/core/user/account_info.ts", "node_modules/@firebase/auth/src/core/user/additional_user_info.ts", "node_modules/@firebase/auth/src/core/index.ts", "node_modules/@firebase/auth/src/mfa/mfa_session.ts", "node_modules/@firebase/auth/src/mfa/mfa_resolver.ts", "node_modules/@firebase/auth/src/api/account_management/mfa.ts", "node_modules/@firebase/auth/src/mfa/mfa_user.ts", "node_modules/@firebase/auth/src/core/auth/firebase_internal.ts", "node_modules/@firebase/auth/src/core/auth/register.ts", "node_modules/@firebase/auth/src/platform_node/index.ts", "node_modules/@firebase/auth/src/api/authentication/mfa.ts", "node_modules/@firebase/auth/src/mfa/mfa_assertion.ts", "node_modules/@firebase/auth/src/mfa/assertions/totp.ts", "node_modules/@firebase/auth/dist/node/index.js", "node_modules/firebase/auth/dist/index.cjs.js", "src/main.ts", "src/auth-manager.ts", "src/upload-modal.ts", "src/markdown-extractor.ts", "src/image-uploader.ts", "src/memo-uploader.ts", "src/settings.ts"],
  "sourcesContent": ["const getDefaultsFromPostinstall = () => (undefined);\nexport { getDefaultsFromPostinstall };", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.\n */\n\nexport const CONSTANTS = {\n  /**\n   * @define {boolean} Whether this is the client Node.js SDK.\n   */\n  NODE_CLIENT: false,\n  /**\n   * @define {boolean} Whether this is the Admin Node.js SDK.\n   */\n  NODE_ADMIN: false,\n\n  /**\n   * Firebase SDK Version\n   */\n  SDK_VERSION: '${JSCORE_VERSION}'\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\n\n/**\n * Throws an error if the provided assertion is falsy\n */\nexport const assert = function (assertion: unknown, message: string): void {\n  if (!assertion) {\n    throw assertionError(message);\n  }\n};\n\n/**\n * Returns an Error object suitable for throwing.\n */\nexport const assertionError = function (message: string): Error {\n  return new Error(\n    'Firebase Database (' +\n      CONSTANTS.SDK_VERSION +\n      ') INTERNAL ASSERT FAILED: ' +\n      message\n  );\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst stringToByteArray = function (str: string): number[] {\n  // TODO(user): Use native implementations if/when available\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (\n      (c & 0xfc00) === 0xd800 &&\n      i + 1 < str.length &&\n      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00\n    ) {\n      // Surrogate Pair\n      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes: number[]): string {\n  // TODO(user): Use native implementations if/when available\n  const out: string[] = [];\n  let pos = 0,\n    c = 0;\n  while (pos < bytes.length) {\n    const c1 = bytes[pos++];\n    if (c1 < 128) {\n      out[c++] = String.fromCharCode(c1);\n    } else if (c1 > 191 && c1 < 224) {\n      const c2 = bytes[pos++];\n      out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\n    } else if (c1 > 239 && c1 < 365) {\n      // Surrogate Pair\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      const c4 = bytes[pos++];\n      const u =\n        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n        0x10000;\n      out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n    } else {\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      out[c++] = String.fromCharCode(\n        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)\n      );\n    }\n  }\n  return out.join('');\n};\n\ninterface Base64 {\n  byteToCharMap_: { [key: number]: string } | null;\n  charToByteMap_: { [key: string]: number } | null;\n  byteToCharMapWebSafe_: { [key: number]: string } | null;\n  charToByteMapWebSafe_: { [key: string]: number } | null;\n  ENCODED_VALS_BASE: string;\n  readonly ENCODED_VALS: string;\n  readonly ENCODED_VALS_WEBSAFE: string;\n  HAS_NATIVE_SUPPORT: boolean;\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string;\n  encodeString(input: string, webSafe?: boolean): string;\n  decodeString(input: string, webSafe: boolean): string;\n  decodeStringToByteArray(input: string, webSafe: boolean): number[];\n  init_(): void;\n}\n\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\n// TODO(dlarocque): Define this as a class, since we no longer target ES5.\nexport const base64: Base64 = {\n  /**\n   * Maps bytes to characters.\n   */\n  byteToCharMap_: null,\n\n  /**\n   * Maps characters to bytes.\n   */\n  charToByteMap_: null,\n\n  /**\n   * Maps bytes to websafe characters.\n   * @private\n   */\n  byteToCharMapWebSafe_: null,\n\n  /**\n   * Maps websafe characters to bytes.\n   * @private\n   */\n  charToByteMapWebSafe_: null,\n\n  /**\n   * Our default alphabet, shared between\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n   */\n  ENCODED_VALS_BASE:\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n\n  /**\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n\n  /**\n   * Our websafe alphabet.\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n\n  /**\n   * Whether this browser supports the atob and btoa functions. This extension\n   * started at Mozilla but is now implemented by many browsers. We use the\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\n   * but still allowing the standard per-browser compilations.\n   *\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n\n  /**\n   * Base64-encode an array of bytes.\n   *\n   * @param input An array of bytes (numbers with\n   *     value in [0, 255]) to encode.\n   * @param webSafe Boolean indicating we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n\n    this.init_();\n\n    const byteToCharMap = webSafe\n      ? this.byteToCharMapWebSafe_!\n      : this.byteToCharMap_!;\n\n    const output = [];\n\n    for (let i = 0; i < input.length; i += 3) {\n      const byte1 = input[i];\n      const haveByte2 = i + 1 < input.length;\n      const byte2 = haveByte2 ? input[i + 1] : 0;\n      const haveByte3 = i + 2 < input.length;\n      const byte3 = haveByte3 ? input[i + 2] : 0;\n\n      const outByte1 = byte1 >> 2;\n      const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\n      let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\n      let outByte4 = byte3 & 0x3f;\n\n      if (!haveByte3) {\n        outByte4 = 64;\n\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n\n      output.push(\n        byteToCharMap[outByte1],\n        byteToCharMap[outByte2],\n        byteToCharMap[outByte3],\n        byteToCharMap[outByte4]\n      );\n    }\n\n    return output.join('');\n  },\n\n  /**\n   * Base64-encode a string.\n   *\n   * @param input A string to encode.\n   * @param webSafe If true, we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeString(input: string, webSafe?: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return btoa(input);\n    }\n    return this.encodeByteArray(stringToByteArray(input), webSafe);\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * @param input to decode.\n   * @param webSafe True if we should use the\n   *     alternative alphabet.\n   * @return string representing the decoded value.\n   */\n  decodeString(input: string, webSafe: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return atob(input);\n    }\n    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * In base-64 decoding, groups of four characters are converted into three\n   * bytes.  If the encoder did not apply padding, the input length may not\n   * be a multiple of 4.\n   *\n   * In this case, the last group will have fewer than 4 characters, and\n   * padding will be inferred.  If the group has one or two characters, it decodes\n   * to one byte.  If the group has three characters, it decodes to two bytes.\n   *\n   * @param input Input to decode.\n   * @param webSafe True if we should use the web-safe alphabet.\n   * @return bytes representing the decoded value.\n   */\n  decodeStringToByteArray(input: string, webSafe: boolean): number[] {\n    this.init_();\n\n    const charToByteMap = webSafe\n      ? this.charToByteMapWebSafe_!\n      : this.charToByteMap_!;\n\n    const output: number[] = [];\n\n    for (let i = 0; i < input.length; ) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw new DecodeBase64StringError();\n      }\n\n      const outByte1 = (byte1 << 2) | (byte2 >> 4);\n      output.push(outByte1);\n\n      if (byte3 !== 64) {\n        const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n        output.push(outByte2);\n\n        if (byte4 !== 64) {\n          const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n\n    return output;\n  },\n\n  /**\n   * Lazy static initialization function. Called before\n   * accessing any of the static map variables.\n   * @private\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n\n      // We want quick mappings back and forth, so we precompute two maps.\n      for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n        this.charToByteMap_[this.byteToCharMap_[i]] = i;\n        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n\n        // Be forgiving when decoding and correctly decode both encodings.\n        if (i >= this.ENCODED_VALS_BASE.length) {\n          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n        }\n      }\n    }\n  }\n};\n\n/**\n * An error encountered while decoding base64 string.\n */\nexport class DecodeBase64StringError extends Error {\n  readonly name = 'DecodeBase64StringError';\n}\n\n/**\n * URL-safe base64 encoding\n */\nexport const base64Encode = function (str: string): string {\n  const utf8Bytes = stringToByteArray(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n\n/**\n * URL-safe base64 encoding (without \".\" padding in the end).\n * e.g. Used in JSON Web Token (JWT) parts.\n */\nexport const base64urlEncodeWithoutPadding = function (str: string): string {\n  // Use base64url encoding and remove padding in the end (dot characters).\n  return base64Encode(str).replace(/\\./g, '');\n};\n\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nexport const base64Decode = function (str: string): string | null {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Do a deep-copy of basic JavaScript Objects or Arrays.\n */\nexport function deepCopy<T>(value: T): T {\n  return deepExtend(undefined, value) as T;\n}\n\n/**\n * Copy properties from source to target (recursively allows extension\n * of Objects and Arrays).  Scalar values in the target are over-written.\n * If target is undefined, an object of the appropriate type will be created\n * (and returned).\n *\n * We recursively copy all child properties of plain Objects in the source- so\n * that namespace- like dictionaries are merged.\n *\n * Note that the target can be a function, in which case the properties in\n * the source Object are copied onto it as static properties of the Function.\n *\n * Note: we don't merge __proto__ to prevent prototype pollution\n */\nexport function deepExtend(target: unknown, source: unknown): unknown {\n  if (!(source instanceof Object)) {\n    return source;\n  }\n\n  switch (source.constructor) {\n    case Date:\n      // Treat Dates like scalars; if the target date object had any child\n      // properties - they will be lost!\n      const dateValue = source as Date;\n      return new Date(dateValue.getTime());\n\n    case Object:\n      if (target === undefined) {\n        target = {};\n      }\n      break;\n    case Array:\n      // Always copy the array source and overwrite the target.\n      target = [];\n      break;\n\n    default:\n      // Not a plain Object - treat it as a scalar.\n      return source;\n  }\n\n  for (const prop in source) {\n    // use isValidKey to guard against prototype pollution. See https://snyk.io/vuln/SNYK-JS-LODASH-450202\n    if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {\n      continue;\n    }\n    (target as Record<string, unknown>)[prop] = deepExtend(\n      (target as Record<string, unknown>)[prop],\n      (source as Record<string, unknown>)[prop]\n    );\n  }\n\n  return target;\n}\n\nfunction isValidKey(key: string): boolean {\n  return key !== '__proto__';\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Polyfill for `globalThis` object.\n * @returns the `globalThis` object for the given environment.\n * @public\n */\nexport function getGlobal(): typeof globalThis {\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('Unable to locate global object.');\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64Decode } from './crypt';\nimport { getGlobal } from './global';\nimport { getDefaultsFromPostinstall } from './postinstall';\n\n/**\n * Keys for experimental properties on the `FirebaseDefaults` object.\n * @public\n */\nexport type ExperimentalKey = 'authTokenSyncURL' | 'authIdTokenMaxAge';\n\n/**\n * An object that can be injected into the environment as __FIREBASE_DEFAULTS__,\n * either as a property of globalThis, a shell environment variable, or a\n * cookie.\n *\n * This object can be used to automatically configure and initialize\n * a Firebase app as well as any emulators.\n *\n * @public\n */\nexport interface FirebaseDefaults {\n  config?: Record<string, string>;\n  emulatorHosts?: Record<string, string>;\n  _authTokenSyncURL?: string;\n  _authIdTokenMaxAge?: number;\n  /**\n   * Override Firebase's runtime environment detection and\n   * force the SDK to act as if it were in the specified environment.\n   */\n  forceEnvironment?: 'browser' | 'node';\n  [key: string]: unknown;\n}\n\ndeclare global {\n  // Need `var` for this to work.\n  // eslint-disable-next-line no-var\n  var __FIREBASE_DEFAULTS__: FirebaseDefaults | undefined;\n}\n\nconst getDefaultsFromGlobal = (): FirebaseDefaults | undefined =>\n  getGlobal().__FIREBASE_DEFAULTS__;\n\n/**\n * Attempt to read defaults from a JSON string provided to\n * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in\n * process(.)env(.)__FIREBASE_DEFAULTS_PATH__\n * The dots are in parens because certain compilers (Vite?) cannot\n * handle seeing that variable in comments.\n * See https://github.com/firebase/firebase-js-sdk/issues/6838\n */\nconst getDefaultsFromEnvVariable = (): FirebaseDefaults | undefined => {\n  if (typeof process === 'undefined' || typeof process.env === 'undefined') {\n    return;\n  }\n  const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;\n  if (defaultsJsonString) {\n    return JSON.parse(defaultsJsonString);\n  }\n};\n\nconst getDefaultsFromCookie = (): FirebaseDefaults | undefined => {\n  if (typeof document === 'undefined') {\n    return;\n  }\n  let match;\n  try {\n    match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);\n  } catch (e) {\n    // Some environments such as Angular Universal SSR have a\n    // `document` object but error on accessing `document.cookie`.\n    return;\n  }\n  const decoded = match && base64Decode(match[1]);\n  return decoded && JSON.parse(decoded);\n};\n\n/**\n * Get the __FIREBASE_DEFAULTS__ object. It checks in order:\n * (1) if such an object exists as a property of `globalThis`\n * (2) if such an object was provided on a shell environment variable\n * (3) if such an object exists in a cookie\n * @public\n */\nexport const getDefaults = (): FirebaseDefaults | undefined => {\n  try {\n    return (\n      getDefaultsFromPostinstall() ||\n      getDefaultsFromGlobal() ||\n      getDefaultsFromEnvVariable() ||\n      getDefaultsFromCookie()\n    );\n  } catch (e) {\n    /**\n     * Catch-all for being unable to get __FIREBASE_DEFAULTS__ due\n     * to any environment case we have not accounted for. Log to\n     * info instead of swallowing so we can find these unknown cases\n     * and add paths for them if needed.\n     */\n    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);\n    return;\n  }\n};\n\n/**\n * Returns emulator host stored in the __FIREBASE_DEFAULTS__ object\n * for the given product.\n * @returns a URL host formatted like `127.0.0.1:9999` or `[::1]:4000` if available\n * @public\n */\nexport const getDefaultEmulatorHost = (\n  productName: string\n): string | undefined => getDefaults()?.emulatorHosts?.[productName];\n\n/**\n * Returns emulator hostname and port stored in the __FIREBASE_DEFAULTS__ object\n * for the given product.\n * @returns a pair of hostname and port like `[\"::1\", 4000]` if available\n * @public\n */\nexport const getDefaultEmulatorHostnameAndPort = (\n  productName: string\n): [hostname: string, port: number] | undefined => {\n  const host = getDefaultEmulatorHost(productName);\n  if (!host) {\n    return undefined;\n  }\n  const separatorIndex = host.lastIndexOf(':'); // Finding the last since IPv6 addr also has colons.\n  if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {\n    throw new Error(`Invalid host ${host} with no separate hostname and port!`);\n  }\n  // eslint-disable-next-line no-restricted-globals\n  const port = parseInt(host.substring(separatorIndex + 1), 10);\n  if (host[0] === '[') {\n    // Bracket-quoted `[ipv6addr]:port` => return \"ipv6addr\" (without brackets).\n    return [host.substring(1, separatorIndex - 1), port];\n  } else {\n    return [host.substring(0, separatorIndex), port];\n  }\n};\n\n/**\n * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.\n * @public\n */\nexport const getDefaultAppConfig = (): Record<string, string> | undefined =>\n  getDefaults()?.config;\n\n/**\n * Returns an experimental setting on the __FIREBASE_DEFAULTS__ object (properties\n * prefixed by \"_\")\n * @public\n */\nexport const getExperimentalSetting = <T extends ExperimentalKey>(\n  name: T\n): FirebaseDefaults[`_${T}`] =>\n  getDefaults()?.[`_${name}`] as FirebaseDefaults[`_${T}`];\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport class Deferred<R> {\n  promise: Promise<R>;\n  reject: (value?: unknown) => void = () => {};\n  resolve: (value?: unknown) => void = () => {};\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve as (value?: unknown) => void;\n      this.reject = reject as (value?: unknown) => void;\n    });\n  }\n\n  /**\n   * Our API internals are not promisified and cannot because our callback APIs have subtle expectations around\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\n   */\n  wrapCallback(\n    callback?: (error?: unknown, value?: unknown) => void\n  ): (error: unknown, value?: unknown) => void {\n    return (error, value?) => {\n      if (error) {\n        this.reject(error);\n      } else {\n        this.resolve(value);\n      }\n      if (typeof callback === 'function') {\n        // Attaching noop handler just in case developer wasn't expecting\n        // promises\n        this.promise.catch(() => {});\n\n        // Some of our callbacks don't expect a value and our own tests\n        // assert that the parameter length is 1\n        if (callback.length === 1) {\n          callback(error);\n        } else {\n          callback(error, value);\n        }\n      }\n    };\n  }\n}\n", "/**\n * @license\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Checks whether host is a cloud workstation or not.\n * @public\n */\nexport function isCloudWorkstation(url: string): boolean {\n  // `isCloudWorkstation` is called without protocol in certain connect*Emulator functions\n  // In HTTP request builders, it's called with the protocol.\n  // If called with protocol prefix, it's a valid URL, so we extract the hostname\n  // If called without, we assume the string is the hostname.\n  try {\n    const host =\n      url.startsWith('http://') || url.startsWith('https://')\n        ? new URL(url).hostname\n        : url;\n    return host.endsWith('.cloudworkstations.dev');\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Makes a fetch request to the given server.\n * Mostly used for forwarding cookies in Firebase Studio.\n * @public\n */\nexport async function pingServer(endpoint: string): Promise<boolean> {\n  const result = await fetch(endpoint, {\n    credentials: 'include'\n  });\n  return result.ok;\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64urlEncodeWithoutPadding } from './crypt';\nimport { isCloudWorkstation } from './url';\n\n// Firebase Auth tokens contain snake_case claims following the JWT standard / convention.\n/* eslint-disable camelcase */\n\nexport type FirebaseSignInProvider =\n  | 'custom'\n  | 'email'\n  | 'password'\n  | 'phone'\n  | 'anonymous'\n  | 'google.com'\n  | 'facebook.com'\n  | 'github.com'\n  | 'twitter.com'\n  | 'microsoft.com'\n  | 'apple.com';\n\ninterface FirebaseIdToken {\n  // Always set to https://securetoken.google.com/PROJECT_ID\n  iss: string;\n\n  // Always set to PROJECT_ID\n  aud: string;\n\n  // The user's unique ID\n  sub: string;\n\n  // The token issue time, in seconds since epoch\n  iat: number;\n\n  // The token expiry time, normally 'iat' + 3600\n  exp: number;\n\n  // The user's unique ID. Must be equal to 'sub'\n  user_id: string;\n\n  // The time the user authenticated, normally 'iat'\n  auth_time: number;\n\n  // The sign in provider, only set when the provider is 'anonymous'\n  provider_id?: 'anonymous';\n\n  // The user's primary email\n  email?: string;\n\n  // The user's email verification status\n  email_verified?: boolean;\n\n  // The user's primary phone number\n  phone_number?: string;\n\n  // The user's display name\n  name?: string;\n\n  // The user's profile photo URL\n  picture?: string;\n\n  // Information on all identities linked to this user\n  firebase: {\n    // The primary sign-in provider\n    sign_in_provider: FirebaseSignInProvider;\n\n    // A map of providers to the user's list of unique identifiers from\n    // each provider\n    identities?: { [provider in FirebaseSignInProvider]?: string[] };\n  };\n\n  // Custom claims set by the developer\n  [claim: string]: unknown;\n\n  uid?: never; // Try to catch a common mistake of \"uid\" (should be \"sub\" instead).\n}\n\nexport type EmulatorMockTokenOptions = ({ user_id: string } | { sub: string }) &\n  Partial<FirebaseIdToken>;\n\nexport function createMockUserToken(\n  token: EmulatorMockTokenOptions,\n  projectId?: string\n): string {\n  if (token.uid) {\n    throw new Error(\n      'The \"uid\" field is no longer supported by mockUserToken. Please use \"sub\" instead for Firebase Auth User ID.'\n    );\n  }\n  // Unsecured JWTs use \"none\" as the algorithm.\n  const header = {\n    alg: 'none',\n    type: 'JWT'\n  };\n\n  const project = projectId || 'demo-project';\n  const iat = token.iat || 0;\n  const sub = token.sub || token.user_id;\n  if (!sub) {\n    throw new Error(\"mockUserToken must contain 'sub' or 'user_id' field!\");\n  }\n\n  const payload: FirebaseIdToken = {\n    // Set all required fields to decent defaults\n    iss: `https://securetoken.google.com/${project}`,\n    aud: project,\n    iat,\n    exp: iat + 3600,\n    auth_time: iat,\n    sub,\n    user_id: sub,\n    firebase: {\n      sign_in_provider: 'custom',\n      identities: {}\n    },\n\n    // Override with user options\n    ...token\n  };\n\n  // Unsecured JWTs use the empty string as a signature.\n  const signature = '';\n  return [\n    base64urlEncodeWithoutPadding(JSON.stringify(header)),\n    base64urlEncodeWithoutPadding(JSON.stringify(payload)),\n    signature\n  ].join('.');\n}\n\ninterface EmulatorStatusMap {\n  [name: string]: boolean;\n}\nconst emulatorStatus: EmulatorStatusMap = {};\n\ninterface EmulatorSummary {\n  prod: string[];\n  emulator: string[];\n}\n\n// Checks whether any products are running on an emulator\nfunction getEmulatorSummary(): EmulatorSummary {\n  const summary: EmulatorSummary = {\n    prod: [],\n    emulator: []\n  };\n  for (const key of Object.keys(emulatorStatus)) {\n    if (emulatorStatus[key]) {\n      summary.emulator.push(key);\n    } else {\n      summary.prod.push(key);\n    }\n  }\n  return summary;\n}\n\nfunction getOrCreateEl(id: string): { created: boolean; element: HTMLElement } {\n  let parentDiv = document.getElementById(id);\n  let created = false;\n  if (!parentDiv) {\n    parentDiv = document.createElement('div');\n    parentDiv.setAttribute('id', id);\n    created = true;\n  }\n  return { created, element: parentDiv };\n}\n\nlet previouslyDismissed = false;\n/**\n * Updates Emulator Banner. Primarily used for Firebase Studio\n * @param name\n * @param isRunningEmulator\n * @public\n */\nexport function updateEmulatorBanner(\n  name: string,\n  isRunningEmulator: boolean\n): void {\n  if (\n    typeof window === 'undefined' ||\n    typeof document === 'undefined' ||\n    !isCloudWorkstation(window.location.host) ||\n    emulatorStatus[name] === isRunningEmulator ||\n    emulatorStatus[name] || // If already set to use emulator, can't go back to prod.\n    previouslyDismissed\n  ) {\n    return;\n  }\n\n  emulatorStatus[name] = isRunningEmulator;\n\n  function prefixedId(id: string): string {\n    return `__firebase__banner__${id}`;\n  }\n  const bannerId = '__firebase__banner';\n  const summary = getEmulatorSummary();\n  const showError = summary.prod.length > 0;\n\n  function tearDown(): void {\n    const element = document.getElementById(bannerId);\n    if (element) {\n      element.remove();\n    }\n  }\n\n  function setupBannerStyles(bannerEl: HTMLElement): void {\n    bannerEl.style.display = 'flex';\n    bannerEl.style.background = '#7faaf0';\n    bannerEl.style.position = 'fixed';\n    bannerEl.style.bottom = '5px';\n    bannerEl.style.left = '5px';\n    bannerEl.style.padding = '.5em';\n    bannerEl.style.borderRadius = '5px';\n    bannerEl.style.alignItems = 'center';\n  }\n\n  function setupIconStyles(prependIcon: SVGElement, iconId: string): void {\n    prependIcon.setAttribute('width', '24');\n    prependIcon.setAttribute('id', iconId);\n    prependIcon.setAttribute('height', '24');\n    prependIcon.setAttribute('viewBox', '0 0 24 24');\n    prependIcon.setAttribute('fill', 'none');\n    prependIcon.style.marginLeft = '-6px';\n  }\n\n  function setupCloseBtn(): HTMLSpanElement {\n    const closeBtn = document.createElement('span');\n    closeBtn.style.cursor = 'pointer';\n    closeBtn.style.marginLeft = '16px';\n    closeBtn.style.fontSize = '24px';\n    closeBtn.innerHTML = ' &times;';\n    closeBtn.onclick = () => {\n      previouslyDismissed = true;\n      tearDown();\n    };\n    return closeBtn;\n  }\n\n  function setupLinkStyles(\n    learnMoreLink: HTMLAnchorElement,\n    learnMoreId: string\n  ): void {\n    learnMoreLink.setAttribute('id', learnMoreId);\n    learnMoreLink.innerText = 'Learn more';\n    learnMoreLink.href =\n      'https://firebase.google.com/docs/studio/preview-apps#preview-backend';\n    learnMoreLink.setAttribute('target', '__blank');\n    learnMoreLink.style.paddingLeft = '5px';\n    learnMoreLink.style.textDecoration = 'underline';\n  }\n\n  function setupDom(): void {\n    const banner = getOrCreateEl(bannerId);\n    const firebaseTextId = prefixedId('text');\n    const firebaseText: HTMLSpanElement =\n      document.getElementById(firebaseTextId) || document.createElement('span');\n    const learnMoreId = prefixedId('learnmore');\n    const learnMoreLink: HTMLAnchorElement =\n      (document.getElementById(learnMoreId) as HTMLAnchorElement) ||\n      document.createElement('a');\n    const prependIconId = prefixedId('preprendIcon');\n    const prependIcon: SVGElement =\n      (document.getElementById(\n        prependIconId\n      ) as HTMLOrSVGElement as SVGElement) ||\n      document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n    if (banner.created) {\n      // update styles\n      const bannerEl = banner.element;\n      setupBannerStyles(bannerEl);\n      setupLinkStyles(learnMoreLink, learnMoreId);\n      const closeBtn = setupCloseBtn();\n      setupIconStyles(prependIcon, prependIconId);\n      bannerEl.append(prependIcon, firebaseText, learnMoreLink, closeBtn);\n      document.body.appendChild(bannerEl);\n    }\n\n    if (showError) {\n      firebaseText.innerText = `Preview backend disconnected.`;\n      prependIcon.innerHTML = `<g clip-path=\"url(#clip0_6013_33858)\">\n<path d=\"M4.8 17.6L12 5.6L19.2 17.6H4.8ZM6.91667 16.4H17.0833L12 7.93333L6.91667 16.4ZM12 15.6C12.1667 15.6 12.3056 15.5444 12.4167 15.4333C12.5389 15.3111 12.6 15.1667 12.6 15C12.6 14.8333 12.5389 14.6944 12.4167 14.5833C12.3056 14.4611 12.1667 14.4 12 14.4C11.8333 14.4 11.6889 14.4611 11.5667 14.5833C11.4556 14.6944 11.4 14.8333 11.4 15C11.4 15.1667 11.4556 15.3111 11.5667 15.4333C11.6889 15.5444 11.8333 15.6 12 15.6ZM11.4 13.6H12.6V10.4H11.4V13.6Z\" fill=\"#212121\"/>\n</g>\n<defs>\n<clipPath id=\"clip0_6013_33858\">\n<rect width=\"24\" height=\"24\" fill=\"white\"/>\n</clipPath>\n</defs>`;\n    } else {\n      prependIcon.innerHTML = `<g clip-path=\"url(#clip0_6083_34804)\">\n<path d=\"M11.4 15.2H12.6V11.2H11.4V15.2ZM12 10C12.1667 10 12.3056 9.94444 12.4167 9.83333C12.5389 9.71111 12.6 9.56667 12.6 9.4C12.6 9.23333 12.5389 9.09444 12.4167 8.98333C12.3056 8.86111 12.1667 8.8 12 8.8C11.8333 8.8 11.6889 8.86111 11.5667 8.98333C11.4556 9.09444 11.4 9.23333 11.4 9.4C11.4 9.56667 11.4556 9.71111 11.5667 9.83333C11.6889 9.94444 11.8333 10 12 10ZM12 18.4C11.1222 18.4 10.2944 18.2333 9.51667 17.9C8.73889 17.5667 8.05556 17.1111 7.46667 16.5333C6.88889 15.9444 6.43333 15.2611 6.1 14.4833C5.76667 13.7056 5.6 12.8778 5.6 12C5.6 11.1111 5.76667 10.2833 6.1 9.51667C6.43333 8.73889 6.88889 8.06111 7.46667 7.48333C8.05556 6.89444 8.73889 6.43333 9.51667 6.1C10.2944 5.76667 11.1222 5.6 12 5.6C12.8889 5.6 13.7167 5.76667 14.4833 6.1C15.2611 6.43333 15.9389 6.89444 16.5167 7.48333C17.1056 8.06111 17.5667 8.73889 17.9 9.51667C18.2333 10.2833 18.4 11.1111 18.4 12C18.4 12.8778 18.2333 13.7056 17.9 14.4833C17.5667 15.2611 17.1056 15.9444 16.5167 16.5333C15.9389 17.1111 15.2611 17.5667 14.4833 17.9C13.7167 18.2333 12.8889 18.4 12 18.4ZM12 17.2C13.4444 17.2 14.6722 16.6944 15.6833 15.6833C16.6944 14.6722 17.2 13.4444 17.2 12C17.2 10.5556 16.6944 9.32778 15.6833 8.31667C14.6722 7.30555 13.4444 6.8 12 6.8C10.5556 6.8 9.32778 7.30555 8.31667 8.31667C7.30556 9.32778 6.8 10.5556 6.8 12C6.8 13.4444 7.30556 14.6722 8.31667 15.6833C9.32778 16.6944 10.5556 17.2 12 17.2Z\" fill=\"#212121\"/>\n</g>\n<defs>\n<clipPath id=\"clip0_6083_34804\">\n<rect width=\"24\" height=\"24\" fill=\"white\"/>\n</clipPath>\n</defs>`;\n      firebaseText.innerText = 'Preview backend running in this workspace.';\n    }\n    firebaseText.setAttribute('id', firebaseTextId);\n  }\n  if (document.readyState === 'loading') {\n    window.addEventListener('DOMContentLoaded', setupDom);\n  } else {\n    setupDom();\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\nimport { getDefaults } from './defaults';\n\n/**\n * Type placeholder for `WorkerGlobalScope` from `webworker`\n */\ndeclare class WorkerGlobalScope {}\n\n/**\n * Returns navigator.userAgent string or '' if it's not defined.\n * @return user agent string\n */\nexport function getUA(): string {\n  if (\n    typeof navigator !== 'undefined' &&\n    typeof navigator['userAgent'] === 'string'\n  ) {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n\n/**\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\n *\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\n * wait for a callback.\n */\nexport function isMobileCordova(): boolean {\n  return (\n    typeof window !== 'undefined' &&\n    // @ts-ignore Setting up an broadly applicable index signature for Window\n    // just to deal with this case would probably be a bad idea.\n    !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&\n    /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA())\n  );\n}\n\n/**\n * Detect Node.js.\n *\n * @return true if Node.js environment is detected or specified.\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nexport function isNode(): boolean {\n  const forceEnvironment = getDefaults()?.forceEnvironment;\n  if (forceEnvironment === 'node') {\n    return true;\n  } else if (forceEnvironment === 'browser') {\n    return false;\n  }\n\n  try {\n    return (\n      Object.prototype.toString.call(global.process) === '[object process]'\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Detect Browser Environment.\n * Note: This will return true for certain test frameworks that are incompletely\n * mimicking a browser, and should not lead to assuming all browser APIs are\n * available.\n */\nexport function isBrowser(): boolean {\n  return typeof window !== 'undefined' || isWebWorker();\n}\n\n/**\n * Detect Web Worker context.\n */\nexport function isWebWorker(): boolean {\n  return (\n    typeof WorkerGlobalScope !== 'undefined' &&\n    typeof self !== 'undefined' &&\n    self instanceof WorkerGlobalScope\n  );\n}\n\n/**\n * Detect Cloudflare Worker context.\n */\nexport function isCloudflareWorker(): boolean {\n  return (\n    typeof navigator !== 'undefined' &&\n    navigator.userAgent === 'Cloudflare-Workers'\n  );\n}\n\n/**\n * Detect browser extensions (Chrome and Firefox at least).\n */\ninterface BrowserRuntime {\n  id?: unknown;\n}\ndeclare const chrome: { runtime?: BrowserRuntime };\ndeclare const browser: { runtime?: BrowserRuntime };\nexport function isBrowserExtension(): boolean {\n  const runtime =\n    typeof chrome === 'object'\n      ? chrome.runtime\n      : typeof browser === 'object'\n      ? browser.runtime\n      : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n\n/**\n * Detect React Native.\n *\n * @return true if ReactNative environment is detected.\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator === 'object' && navigator['product'] === 'ReactNative'\n  );\n}\n\n/** Detects Electron apps. */\nexport function isElectron(): boolean {\n  return getUA().indexOf('Electron/') >= 0;\n}\n\n/** Detects Internet Explorer. */\nexport function isIE(): boolean {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n\n/** Detects Universal Windows Platform apps. */\nexport function isUWP(): boolean {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n\n/**\n * Detect whether the current SDK build is the Node version.\n *\n * @return true if it's the Node SDK build.\n */\nexport function isNodeSdk(): boolean {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n\n/** Returns true if we are running in Safari. */\nexport function isSafari(): boolean {\n  return (\n    !isNode() &&\n    !!navigator.userAgent &&\n    navigator.userAgent.includes('Safari') &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/** Returns true if we are running in Safari or WebKit */\nexport function isSafariOrWebkit(): boolean {\n  return (\n    !isNode() &&\n    !!navigator.userAgent &&\n    (navigator.userAgent.includes('Safari') ||\n      navigator.userAgent.includes('WebKit')) &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nexport function isIndexedDBAvailable(): boolean {\n  try {\n    return typeof indexedDB === 'object';\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\n *\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\n * private browsing)\n */\nexport function validateIndexedDBOpenable(): Promise<boolean> {\n  return new Promise((resolve, reject) => {\n    try {\n      let preExist: boolean = true;\n      const DB_CHECK_NAME =\n        'validate-browser-context-for-indexeddb-analytics-module';\n      const request = self.indexedDB.open(DB_CHECK_NAME);\n      request.onsuccess = () => {\n        request.result.close();\n        // delete database only when it doesn't pre-exist\n        if (!preExist) {\n          self.indexedDB.deleteDatabase(DB_CHECK_NAME);\n        }\n        resolve(true);\n      };\n      request.onupgradeneeded = () => {\n        preExist = false;\n      };\n\n      request.onerror = () => {\n        reject(request.error?.message || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n\n/**\n *\n * This method checks whether cookie is enabled within current browser\n * @return true if cookie is enabled within current browser\n */\nexport function areCookiesEnabled(): boolean {\n  if (typeof navigator === 'undefined' || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // TypeScript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if ((e as FirebaseError)?.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\n\nexport type ErrorMap<ErrorCode extends string> = {\n  readonly [K in ErrorCode]: string;\n};\n\nconst ERROR_NAME = 'FirebaseError';\n\nexport interface StringLike {\n  toString(): string;\n}\n\nexport interface ErrorData {\n  [key: string]: unknown;\n}\n\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nexport class FirebaseError extends Error {\n  /** The custom name for all FirebaseErrors. */\n  readonly name: string = ERROR_NAME;\n\n  constructor(\n    /** The error code for this error. */\n    readonly code: string,\n    message: string,\n    /** Custom data for this error. */\n    public customData?: Record<string, unknown>\n  ) {\n    super(message);\n\n    // Fix For ES5\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    // TODO(dlarocque): Replace this with `new.target`: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget\n    //                   which we can now use since we no longer target ES5.\n    Object.setPrototypeOf(this, FirebaseError.prototype);\n\n    // Maintains proper stack trace for where our error was thrown.\n    // Only available on V8.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ErrorFactory.prototype.create);\n    }\n  }\n}\n\nexport class ErrorFactory<\n  ErrorCode extends string,\n  ErrorParams extends { readonly [K in ErrorCode]?: ErrorData } = {}\n> {\n  constructor(\n    private readonly service: string,\n    private readonly serviceName: string,\n    private readonly errors: ErrorMap<ErrorCode>\n  ) {}\n\n  create<K extends ErrorCode>(\n    code: K,\n    ...data: K extends keyof ErrorParams ? [ErrorParams[K]] : []\n  ): FirebaseError {\n    const customData = (data[0] as ErrorData) || {};\n    const fullCode = `${this.service}/${code}`;\n    const template = this.errors[code];\n\n    const message = template ? replaceTemplate(template, customData) : 'Error';\n    // Service Name: Error message (service/code).\n    const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n\n    const error = new FirebaseError(fullCode, fullMessage, customData);\n\n    return error;\n  }\n}\n\nfunction replaceTemplate(template: string, data: ErrorData): string {\n  return template.replace(PATTERN, (_, key) => {\n    const value = data[key];\n    return value != null ? String(value) : `<${key}?>`;\n  });\n}\n\nconst PATTERN = /\\{\\$([^}]+)}/g;\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Evaluates a JSON string into a javascript object.\n *\n * @param {string} str A string containing JSON.\n * @return {*} The javascript object representing the specified JSON.\n */\nexport function jsonEval(str: string): unknown {\n  return JSON.parse(str);\n}\n\n/**\n * Returns JSON representing a javascript object.\n * @param {*} data JavaScript object to be stringified.\n * @return {string} The JSON contents of the object.\n */\nexport function stringify(data: unknown): string {\n  return JSON.stringify(data);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64Decode } from './crypt';\nimport { jsonEval } from './json';\n\ninterface Claims {\n  [key: string]: {};\n}\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token into constituent parts.\n *\n * Notes:\n * - May return with invalid / incomplete claims if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const decode = function (token: string): DecodedToken {\n  let header = {},\n    claims: Claims = {},\n    data = {},\n    signature = '';\n\n  try {\n    const parts = token.split('.');\n    header = jsonEval(base64Decode(parts[0]) || '') as object;\n    claims = jsonEval(base64Decode(parts[1]) || '') as Claims;\n    signature = parts[2];\n    data = claims['d'] || {};\n    delete claims['d'];\n  } catch (e) {}\n\n  return {\n    header,\n    claims,\n    data,\n    signature\n  };\n};\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the\n * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidTimestamp = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  const now: number = Math.floor(new Date().getTime() / 1000);\n  let validSince: number = 0,\n    validUntil: number = 0;\n\n  if (typeof claims === 'object') {\n    if (claims.hasOwnProperty('nbf')) {\n      validSince = claims['nbf'] as number;\n    } else if (claims.hasOwnProperty('iat')) {\n      validSince = claims['iat'] as number;\n    }\n\n    if (claims.hasOwnProperty('exp')) {\n      validUntil = claims['exp'] as number;\n    } else {\n      // token will expire after 24h by default\n      validUntil = validSince + 86400;\n    }\n  }\n\n  return (\n    !!now &&\n    !!validSince &&\n    !!validUntil &&\n    now >= validSince &&\n    now <= validUntil\n  );\n};\n\n/**\n * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.\n *\n * Notes:\n * - May return null if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const issuedAtTime = function (token: string): number | null {\n  const claims: Claims = decode(token).claims;\n  if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {\n    return claims['iat'] as number;\n  }\n  return null;\n};\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidFormat = function (token: string): boolean {\n  const decoded = decode(token),\n    claims = decoded.claims;\n\n  return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');\n};\n\n/**\n * Attempts to peer into an auth token and determine if it's an admin auth token by looking at the claims portion.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isAdmin = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  return typeof claims === 'object' && claims['admin'] === true;\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function contains<T extends object>(obj: T, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\n\nexport function safeGet<T extends object, K extends keyof T>(\n  obj: T,\n  key: K\n): T[K] | undefined {\n  if (Object.prototype.hasOwnProperty.call(obj, key)) {\n    return obj[key];\n  } else {\n    return undefined;\n  }\n}\n\nexport function isEmpty(obj: object): obj is {} {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function map<K extends string, V, U>(\n  obj: { [key in K]: V },\n  fn: (value: V, key: K, obj: { [key in K]: V }) => U,\n  contextObj?: unknown\n): { [key in K]: U } {\n  const res: Partial<{ [key in K]: U }> = {};\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      res[key] = fn.call(contextObj, obj[key], key, obj);\n    }\n  }\n  return res as { [key in K]: U };\n}\n\n/**\n * Deep equal two objects. Support Arrays and Objects.\n */\nexport function deepEqual(a: object, b: object): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  for (const k of aKeys) {\n    if (!bKeys.includes(k)) {\n      return false;\n    }\n\n    const aProp = (a as Record<string, unknown>)[k];\n    const bProp = (b as Record<string, unknown>)[k];\n    if (isObject(aProp) && isObject(bProp)) {\n      if (!deepEqual(aProp, bProp)) {\n        return false;\n      }\n    } else if (aProp !== bProp) {\n      return false;\n    }\n  }\n\n  for (const k of bKeys) {\n    if (!aKeys.includes(k)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isObject(thing: unknown): thing is object {\n  return thing !== null && typeof thing === 'object';\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Deferred } from './deferred';\n\n/**\n * Rejects if the given promise doesn't resolve in timeInMS milliseconds.\n * @internal\n */\nexport function promiseWithTimeout<T>(\n  promise: Promise<T>,\n  timeInMS = 2000\n): Promise<T> {\n  const deferredPromise = new Deferred<T>();\n  setTimeout(() => deferredPromise.reject('timeout!'), timeInMS);\n  promise.then(deferredPromise.resolve, deferredPromise.reject);\n  return deferredPromise.promise;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Returns a querystring-formatted string (e.g. &arg=val&arg2=val2) from a\n * params object (e.g. {arg: 'val', arg2: 'val2'})\n * Note: You must prepend it with ? when adding it to a URL.\n */\nexport function querystring(querystringParams: {\n  [key: string]: string | number;\n}): string {\n  const params = [];\n  for (const [key, value] of Object.entries(querystringParams)) {\n    if (Array.isArray(value)) {\n      value.forEach(arrayVal => {\n        params.push(\n          encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal)\n        );\n      });\n    } else {\n      params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    }\n  }\n  return params.length ? '&' + params.join('&') : '';\n}\n\n/**\n * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object\n * (e.g. {arg: 'val', arg2: 'val2'})\n */\nexport function querystringDecode(querystring: string): Record<string, string> {\n  const obj: Record<string, string> = {};\n  const tokens = querystring.replace(/^\\?/, '').split('&');\n\n  tokens.forEach(token => {\n    if (token) {\n      const [key, value] = token.split('=');\n      obj[decodeURIComponent(key)] = decodeURIComponent(value);\n    }\n  });\n  return obj;\n}\n\n/**\n * Extract the query string part of a URL, including the leading question mark (if present).\n */\nexport function extractQuerystring(url: string): string {\n  const queryStart = url.indexOf('?');\n  if (!queryStart) {\n    return '';\n  }\n  const fragmentStart = url.indexOf('#', queryStart);\n  return url.substring(\n    queryStart,\n    fragmentStart > 0 ? fragmentStart : undefined\n  );\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview SHA-1 cryptographic hash.\n * Variable names follow the notation in FIPS PUB 180-3:\n * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf.\n *\n * Usage:\n *   var sha1 = new sha1();\n *   sha1.update(bytes);\n *   var hash = sha1.digest();\n *\n * Performance:\n *   Chrome 23:   ~400 Mbit/s\n *   Firefox 16:  ~250 Mbit/s\n *\n */\n\n/**\n * SHA-1 cryptographic hash constructor.\n *\n * The properties declared here are discussed in the above algorithm document.\n * @constructor\n * @final\n * @struct\n */\nexport class Sha1 {\n  /**\n   * Holds the previous values of accumulated variables a-e in the compress_\n   * function.\n   * @private\n   */\n  private chain_: number[] = [];\n\n  /**\n   * A buffer holding the partially computed hash result.\n   * @private\n   */\n  private buf_: number[] = [];\n\n  /**\n   * An array of 80 bytes, each a part of the message to be hashed.  Referred to\n   * as the message schedule in the docs.\n   * @private\n   */\n  private W_: number[] = [];\n\n  /**\n   * Contains data needed to pad messages less than 64 bytes.\n   * @private\n   */\n  private pad_: number[] = [];\n\n  /**\n   * @private {number}\n   */\n  private inbuf_: number = 0;\n\n  /**\n   * @private {number}\n   */\n  private total_: number = 0;\n\n  blockSize: number;\n\n  constructor() {\n    this.blockSize = 512 / 8;\n\n    this.pad_[0] = 128;\n    for (let i = 1; i < this.blockSize; ++i) {\n      this.pad_[i] = 0;\n    }\n\n    this.reset();\n  }\n\n  reset(): void {\n    this.chain_[0] = 0x67452301;\n    this.chain_[1] = 0xefcdab89;\n    this.chain_[2] = 0x98badcfe;\n    this.chain_[3] = 0x10325476;\n    this.chain_[4] = 0xc3d2e1f0;\n\n    this.inbuf_ = 0;\n    this.total_ = 0;\n  }\n\n  /**\n   * Internal compress helper function.\n   * @param buf Block to compress.\n   * @param offset Offset of the block in the buffer.\n   * @private\n   */\n  compress_(buf: number[] | Uint8Array | string, offset?: number): void {\n    if (!offset) {\n      offset = 0;\n    }\n\n    const W = this.W_;\n\n    // get 16 big endian words\n    if (typeof buf === 'string') {\n      for (let i = 0; i < 16; i++) {\n        // TODO(user): [bug 8140122] Recent versions of Safari for Mac OS and iOS\n        // have a bug that turns the post-increment ++ operator into pre-increment\n        // during JIT compilation.  We have code that depends heavily on SHA-1 for\n        // correctness and which is affected by this bug, so I've removed all uses\n        // of post-increment ++ in which the result value is used.  We can revert\n        // this change once the Safari bug\n        // (https://bugs.webkit.org/show_bug.cgi?id=109036) has been fixed and\n        // most clients have been updated.\n        W[i] =\n          (buf.charCodeAt(offset) << 24) |\n          (buf.charCodeAt(offset + 1) << 16) |\n          (buf.charCodeAt(offset + 2) << 8) |\n          buf.charCodeAt(offset + 3);\n        offset += 4;\n      }\n    } else {\n      for (let i = 0; i < 16; i++) {\n        W[i] =\n          (buf[offset] << 24) |\n          (buf[offset + 1] << 16) |\n          (buf[offset + 2] << 8) |\n          buf[offset + 3];\n        offset += 4;\n      }\n    }\n\n    // expand to 80 words\n    for (let i = 16; i < 80; i++) {\n      const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n      W[i] = ((t << 1) | (t >>> 31)) & 0xffffffff;\n    }\n\n    let a = this.chain_[0];\n    let b = this.chain_[1];\n    let c = this.chain_[2];\n    let d = this.chain_[3];\n    let e = this.chain_[4];\n    let f, k;\n\n    // TODO(user): Try to unroll this loop to speed up the computation.\n    for (let i = 0; i < 80; i++) {\n      if (i < 40) {\n        if (i < 20) {\n          f = d ^ (b & (c ^ d));\n          k = 0x5a827999;\n        } else {\n          f = b ^ c ^ d;\n          k = 0x6ed9eba1;\n        }\n      } else {\n        if (i < 60) {\n          f = (b & c) | (d & (b | c));\n          k = 0x8f1bbcdc;\n        } else {\n          f = b ^ c ^ d;\n          k = 0xca62c1d6;\n        }\n      }\n\n      const t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) & 0xffffffff;\n      e = d;\n      d = c;\n      c = ((b << 30) | (b >>> 2)) & 0xffffffff;\n      b = a;\n      a = t;\n    }\n\n    this.chain_[0] = (this.chain_[0] + a) & 0xffffffff;\n    this.chain_[1] = (this.chain_[1] + b) & 0xffffffff;\n    this.chain_[2] = (this.chain_[2] + c) & 0xffffffff;\n    this.chain_[3] = (this.chain_[3] + d) & 0xffffffff;\n    this.chain_[4] = (this.chain_[4] + e) & 0xffffffff;\n  }\n\n  update(bytes?: number[] | Uint8Array | string, length?: number): void {\n    // TODO(johnlenz): tighten the function signature and remove this check\n    if (bytes == null) {\n      return;\n    }\n\n    if (length === undefined) {\n      length = bytes.length;\n    }\n\n    const lengthMinusBlock = length - this.blockSize;\n    let n = 0;\n    // Using local instead of member variables gives ~5% speedup on Firefox 16.\n    const buf = this.buf_;\n    let inbuf = this.inbuf_;\n\n    // The outer while loop should execute at most twice.\n    while (n < length) {\n      // When we have no data in the block to top up, we can directly process the\n      // input buffer (assuming it contains sufficient data). This gives ~25%\n      // speedup on Chrome 23 and ~15% speedup on Firefox 16, but requires that\n      // the data is provided in large chunks (or in multiples of 64 bytes).\n      if (inbuf === 0) {\n        while (n <= lengthMinusBlock) {\n          this.compress_(bytes, n);\n          n += this.blockSize;\n        }\n      }\n\n      if (typeof bytes === 'string') {\n        while (n < length) {\n          buf[inbuf] = bytes.charCodeAt(n);\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      } else {\n        while (n < length) {\n          buf[inbuf] = bytes[n];\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      }\n    }\n\n    this.inbuf_ = inbuf;\n    this.total_ += length;\n  }\n\n  /** @override */\n  digest(): number[] {\n    const digest: number[] = [];\n    let totalBits = this.total_ * 8;\n\n    // Add pad 0x80 0x00*.\n    if (this.inbuf_ < 56) {\n      this.update(this.pad_, 56 - this.inbuf_);\n    } else {\n      this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));\n    }\n\n    // Add # bits.\n    for (let i = this.blockSize - 1; i >= 56; i--) {\n      this.buf_[i] = totalBits & 255;\n      totalBits /= 256; // Don't use bit-shifting here!\n    }\n\n    this.compress_(this.buf_);\n\n    let n = 0;\n    for (let i = 0; i < 5; i++) {\n      for (let j = 24; j >= 0; j -= 8) {\n        digest[n] = (this.chain_[i] >> j) & 255;\n        ++n;\n      }\n    }\n    return digest;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport type NextFn<T> = (value: T) => void;\nexport type ErrorFn = (error: Error) => void;\nexport type CompleteFn = () => void;\n\nexport interface Observer<T> {\n  // Called once for each value in a stream of values.\n  next: NextFn<T>;\n\n  // A stream terminates by a single call to EITHER error() or complete().\n  error: ErrorFn;\n\n  // No events will be sent to next() once complete() is called.\n  complete: CompleteFn;\n}\n\nexport type PartialObserver<T> = Partial<Observer<T>>;\n\n// TODO: Support also Unsubscribe.unsubscribe?\nexport type Unsubscribe = () => void;\n\n/**\n * The Subscribe interface has two forms - passing the inline function\n * callbacks, or a object interface with callback properties.\n */\nexport interface Subscribe<T> {\n  (next?: NextFn<T>, error?: ErrorFn, complete?: CompleteFn): Unsubscribe;\n  (observer: PartialObserver<T>): Unsubscribe;\n}\n\nexport interface Observable<T> {\n  // Subscribe method\n  subscribe: Subscribe<T>;\n}\n\nexport type Executor<T> = (observer: Observer<T>) => void;\n\n/**\n * Helper to make a Subscribe function (just like Promise helps make a\n * Thenable).\n *\n * @param executor Function which can make calls to a single Observer\n *     as a proxy.\n * @param onNoObservers Callback when count of Observers goes to zero.\n */\nexport function createSubscribe<T>(\n  executor: Executor<T>,\n  onNoObservers?: Executor<T>\n): Subscribe<T> {\n  const proxy = new ObserverProxy<T>(executor, onNoObservers);\n  return proxy.subscribe.bind(proxy);\n}\n\n/**\n * Implement fan-out for any number of Observers attached via a subscribe\n * function.\n */\nclass ObserverProxy<T> implements Observer<T> {\n  private observers: Array<Observer<T>> | undefined = [];\n  private unsubscribes: Unsubscribe[] = [];\n  private onNoObservers: Executor<T> | undefined;\n  private observerCount = 0;\n  // Micro-task scheduling by calling task.then().\n  private task = Promise.resolve();\n  private finalized = false;\n  private finalError?: Error;\n\n  /**\n   * @param executor Function which can make calls to a single Observer\n   *     as a proxy.\n   * @param onNoObservers Callback when count of Observers goes to zero.\n   */\n  constructor(executor: Executor<T>, onNoObservers?: Executor<T>) {\n    this.onNoObservers = onNoObservers;\n    // Call the executor asynchronously so subscribers that are called\n    // synchronously after the creation of the subscribe function\n    // can still receive the very first value generated in the executor.\n    this.task\n      .then(() => {\n        executor(this);\n      })\n      .catch(e => {\n        this.error(e);\n      });\n  }\n\n  next(value: T): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.next(value);\n    });\n  }\n\n  error(error: Error): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.error(error);\n    });\n    this.close(error);\n  }\n\n  complete(): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.complete();\n    });\n    this.close();\n  }\n\n  /**\n   * Subscribe function that can be used to add an Observer to the fan-out list.\n   *\n   * - We require that no event is sent to a subscriber synchronously to their\n   *   call to subscribe().\n   */\n  subscribe(\n    nextOrObserver?: NextFn<T> | PartialObserver<T>,\n    error?: ErrorFn,\n    complete?: CompleteFn\n  ): Unsubscribe {\n    let observer: Observer<T>;\n\n    if (\n      nextOrObserver === undefined &&\n      error === undefined &&\n      complete === undefined\n    ) {\n      throw new Error('Missing Observer.');\n    }\n\n    // Assemble an Observer object when passed as callback functions.\n    if (\n      implementsAnyMethods(nextOrObserver as { [key: string]: unknown }, [\n        'next',\n        'error',\n        'complete'\n      ])\n    ) {\n      observer = nextOrObserver as Observer<T>;\n    } else {\n      observer = {\n        next: nextOrObserver as NextFn<T>,\n        error,\n        complete\n      } as Observer<T>;\n    }\n\n    if (observer.next === undefined) {\n      observer.next = noop as NextFn<T>;\n    }\n    if (observer.error === undefined) {\n      observer.error = noop as ErrorFn;\n    }\n    if (observer.complete === undefined) {\n      observer.complete = noop as CompleteFn;\n    }\n\n    const unsub = this.unsubscribeOne.bind(this, this.observers!.length);\n\n    // Attempt to subscribe to a terminated Observable - we\n    // just respond to the Observer with the final error or complete\n    // event.\n    if (this.finalized) {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.task.then(() => {\n        try {\n          if (this.finalError) {\n            observer.error(this.finalError);\n          } else {\n            observer.complete();\n          }\n        } catch (e) {\n          // nothing\n        }\n        return;\n      });\n    }\n\n    this.observers!.push(observer as Observer<T>);\n\n    return unsub;\n  }\n\n  // Unsubscribe is synchronous - we guarantee that no events are sent to\n  // any unsubscribed Observer.\n  private unsubscribeOne(i: number): void {\n    if (this.observers === undefined || this.observers[i] === undefined) {\n      return;\n    }\n\n    delete this.observers[i];\n\n    this.observerCount -= 1;\n    if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n      this.onNoObservers(this);\n    }\n  }\n\n  private forEachObserver(fn: (observer: Observer<T>) => void): void {\n    if (this.finalized) {\n      // Already closed by previous event....just eat the additional values.\n      return;\n    }\n\n    // Since sendOne calls asynchronously - there is no chance that\n    // this.observers will become undefined.\n    for (let i = 0; i < this.observers!.length; i++) {\n      this.sendOne(i, fn);\n    }\n  }\n\n  // Call the Observer via one of it's callback function. We are careful to\n  // confirm that the observe has not been unsubscribed since this asynchronous\n  // function had been queued.\n  private sendOne(i: number, fn: (observer: Observer<T>) => void): void {\n    // Execute the callback asynchronously\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      if (this.observers !== undefined && this.observers[i] !== undefined) {\n        try {\n          fn(this.observers[i]);\n        } catch (e) {\n          // Ignore exceptions raised in Observers or missing methods of an\n          // Observer.\n          // Log error to console. b/31404806\n          if (typeof console !== 'undefined' && console.error) {\n            console.error(e);\n          }\n        }\n      }\n    });\n  }\n\n  private close(err?: Error): void {\n    if (this.finalized) {\n      return;\n    }\n    this.finalized = true;\n    if (err !== undefined) {\n      this.finalError = err;\n    }\n    // Proxy is no longer needed - garbage collect references\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      this.observers = undefined;\n      this.onNoObservers = undefined;\n    });\n  }\n}\n\n/** Turn synchronous function into one called asynchronously. */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function async(fn: Function, onError?: ErrorFn): Function {\n  return (...args: unknown[]) => {\n    Promise.resolve(true)\n      .then(() => {\n        fn(...args);\n      })\n      .catch((error: Error) => {\n        if (onError) {\n          onError(error);\n        }\n      });\n  };\n}\n\n/**\n * Return true if the object passed in implements any of the named methods.\n */\nfunction implementsAnyMethods(\n  obj: { [key: string]: unknown },\n  methods: string[]\n): boolean {\n  if (typeof obj !== 'object' || obj === null) {\n    return false;\n  }\n\n  for (const method of methods) {\n    if (method in obj && typeof obj[method] === 'function') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction noop(): void {\n  // do nothing\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Check to make sure the appropriate number of arguments are provided for a public function.\n * Throws an error if it fails.\n *\n * @param fnName The function name\n * @param minCount The minimum number of arguments to allow for the function call\n * @param maxCount The maximum number of argument to allow for the function call\n * @param argCount The actual number of arguments provided.\n */\nexport const validateArgCount = function (\n  fnName: string,\n  minCount: number,\n  maxCount: number,\n  argCount: number\n): void {\n  let argError;\n  if (argCount < minCount) {\n    argError = 'at least ' + minCount;\n  } else if (argCount > maxCount) {\n    argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;\n  }\n  if (argError) {\n    const error =\n      fnName +\n      ' failed: Was called with ' +\n      argCount +\n      (argCount === 1 ? ' argument.' : ' arguments.') +\n      ' Expects ' +\n      argError +\n      '.';\n    throw new Error(error);\n  }\n};\n\n/**\n * Generates a string to prefix an error message about failed argument validation\n *\n * @param fnName The function name\n * @param argName The name of the argument\n * @return The prefix to add to the error thrown for validation.\n */\nexport function errorPrefix(fnName: string, argName: string): string {\n  return `${fnName} failed: ${argName} argument `;\n}\n\n/**\n * @param fnName\n * @param argumentNumber\n * @param namespace\n * @param optional\n */\nexport function validateNamespace(\n  fnName: string,\n  namespace: string,\n  optional: boolean\n): void {\n  if (optional && !namespace) {\n    return;\n  }\n  if (typeof namespace !== 'string') {\n    //TODO: I should do more validation here. We only allow certain chars in namespaces.\n    throw new Error(\n      errorPrefix(fnName, 'namespace') + 'must be a valid firebase namespace.'\n    );\n  }\n}\n\nexport function validateCallback(\n  fnName: string,\n  argumentName: string,\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  callback: Function,\n  optional: boolean\n): void {\n  if (optional && !callback) {\n    return;\n  }\n  if (typeof callback !== 'function') {\n    throw new Error(\n      errorPrefix(fnName, argumentName) + 'must be a valid function.'\n    );\n  }\n}\n\nexport function validateContextObject(\n  fnName: string,\n  argumentName: string,\n  context: unknown,\n  optional: boolean\n): void {\n  if (optional && !context) {\n    return;\n  }\n  if (typeof context !== 'object' || context === null) {\n    throw new Error(\n      errorPrefix(fnName, argumentName) + 'must be a valid context object.'\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { assert } from './assert';\n\n// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they\n// automatically replaced '\\r\\n' with '\\n', and they didn't handle surrogate pairs,\n// so it's been modified.\n\n// Note that not all Unicode characters appear as single characters in JavaScript strings.\n// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters\n// use 2 characters in JavaScript.  All 4-byte UTF-8 characters begin with a first\n// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate\n// pair).\n// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3\n\n/**\n * @param {string} str\n * @return {Array}\n */\nexport const stringToByteArray = function (str: string): number[] {\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n\n    // Is this the lead surrogate in a surrogate pair?\n    if (c >= 0xd800 && c <= 0xdbff) {\n      const high = c - 0xd800; // the high 10 bits.\n      i++;\n      assert(i < str.length, 'Surrogate pair missing trail surrogate.');\n      const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.\n      c = 0x10000 + (high << 10) + low;\n    }\n\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (c < 65536) {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Calculate length without actually converting; useful for doing cheaper validation.\n * @param {string} str\n * @return {number}\n */\nexport const stringLength = function (str: string): number {\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    const c = str.charCodeAt(i);\n    if (c < 128) {\n      p++;\n    } else if (c < 2048) {\n      p += 2;\n    } else if (c >= 0xd800 && c <= 0xdbff) {\n      // Lead surrogate of a surrogate pair.  The pair together will take 4 bytes to represent.\n      p += 4;\n      i++; // skip trail surrogate.\n    } else {\n      p += 3;\n    }\n  }\n  return p;\n};\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The amount of milliseconds to exponentially increase.\n */\nconst DEFAULT_INTERVAL_MILLIS = 1000;\n\n/**\n * The factor to backoff by.\n * Should be a number greater than 1.\n */\nconst DEFAULT_BACKOFF_FACTOR = 2;\n\n/**\n * The maximum milliseconds to increase to.\n *\n * <p>Visible for testing\n */\nexport const MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.\n\n/**\n * The percentage of backoff time to randomize by.\n * See\n * http://go/safe-client-behavior#step-1-determine-the-appropriate-retry-interval-to-handle-spike-traffic\n * for context.\n *\n * <p>Visible for testing\n */\nexport const RANDOM_FACTOR = 0.5;\n\n/**\n * Based on the backoff method from\n * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js.\n * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around.\n */\nexport function calculateBackoffMillis(\n  backoffCount: number,\n  intervalMillis: number = DEFAULT_INTERVAL_MILLIS,\n  backoffFactor: number = DEFAULT_BACKOFF_FACTOR\n): number {\n  // Calculates an exponentially increasing value.\n  // Deviation: calculates value from count and a constant interval, so we only need to save value\n  // and count to restore state.\n  const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);\n\n  // A random \"fuzz\" to avoid waves of retries.\n  // Deviation: randomFactor is required.\n  const randomWait = Math.round(\n    // A fraction of the backoff value to add/subtract.\n    // Deviation: changes multiplication order to improve readability.\n    RANDOM_FACTOR *\n      currBaseValue *\n      // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines\n      // if we add or subtract.\n      (Math.random() - 0.5) *\n      2\n  );\n\n  // Limits backoff to max to avoid effectively permanent backoff.\n  return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Provide English ordinal letters after a number\n */\nexport function ordinal(i: number): string {\n  if (!Number.isFinite(i)) {\n    return `${i}`;\n  }\n  return i + indicator(i);\n}\n\nfunction indicator(i: number): string {\n  i = Math.abs(i);\n  const cent = i % 100;\n  if (cent >= 10 && cent <= 20) {\n    return 'th';\n  }\n  const dec = i % 10;\n  if (dec === 1) {\n    return 'st';\n  }\n  if (dec === 2) {\n    return 'nd';\n  }\n  if (dec === 3) {\n    return 'rd';\n  }\n  return 'th';\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface Compat<T> {\n  _delegate: T;\n}\n\nexport function getModularInstance<ExpService>(\n  service: Compat<ExpService> | ExpService\n): ExpService {\n  if (service && (service as Compat<ExpService>)._delegate) {\n    return (service as Compat<ExpService>)._delegate;\n  } else {\n    return service as ExpService;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './src/constants';\n\n// Overriding the constant (we should be the only ones doing this)\nCONSTANTS.NODE_CLIENT = true;\n\nexport * from './src/assert';\nexport * from './src/crypt';\nexport * from './src/constants';\nexport * from './src/deepCopy';\nexport * from './src/defaults';\nexport * from './src/deferred';\nexport * from './src/emulator';\nexport * from './src/environment';\nexport * from './src/errors';\nexport * from './src/json';\nexport * from './src/jwt';\nexport * from './src/obj';\nexport * from './src/promise';\nexport * from './src/query';\nexport * from './src/sha1';\nexport * from './src/subscribe';\nexport * from './src/validation';\nexport * from './src/utf8';\nexport * from './src/exponential_backoff';\nexport * from './src/formatters';\nexport * from './src/compat';\nexport * from './src/global';\nexport * from './src/url';\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  InstantiationMode,\n  InstanceFactory,\n  ComponentType,\n  Dictionary,\n  Name,\n  onInstanceCreatedCallback\n} from './types';\n\n/**\n * Component for service name T, e.g. `auth`, `auth-internal`\n */\nexport class Component<T extends Name = Name> {\n  multipleInstances = false;\n  /**\n   * Properties to be added to the service namespace\n   */\n  serviceProps: Dictionary = {};\n\n  instantiationMode = InstantiationMode.LAZY;\n\n  onInstanceCreated: onInstanceCreatedCallback<T> | null = null;\n\n  /**\n   *\n   * @param name The public service name, e.g. app, auth, firestore, database\n   * @param instanceFactory Service factory responsible for creating the public interface\n   * @param type whether the service provided by the component is public or private\n   */\n  constructor(\n    readonly name: T,\n    readonly instanceFactory: InstanceFactory<T>,\n    readonly type: ComponentType\n  ) {}\n\n  setInstantiationMode(mode: InstantiationMode): this {\n    this.instantiationMode = mode;\n    return this;\n  }\n\n  setMultipleInstances(multipleInstances: boolean): this {\n    this.multipleInstances = multipleInstances;\n    return this;\n  }\n\n  setServiceProps(props: Dictionary): this {\n    this.serviceProps = props;\n    return this;\n  }\n\n  setInstanceCreatedCallback(callback: onInstanceCreatedCallback<T>): this {\n    this.onInstanceCreated = callback;\n    return this;\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Deferred } from '@firebase/util';\nimport { ComponentContainer } from './component_container';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport {\n  InitializeOptions,\n  InstantiationMode,\n  Name,\n  NameServiceMapping,\n  OnInitCallBack\n} from './types';\nimport { Component } from './component';\n\n/**\n * Provider for instance for service name T, e.g. 'auth', 'auth-internal'\n * NameServiceMapping[T] is an alias for the type of the instance\n */\nexport class Provider<T extends Name> {\n  private component: Component<T> | null = null;\n  private readonly instances: Map<string, NameServiceMapping[T]> = new Map();\n  private readonly instancesDeferred: Map<\n    string,\n    Deferred<NameServiceMapping[T]>\n  > = new Map();\n  private readonly instancesOptions: Map<string, Record<string, unknown>> =\n    new Map();\n  private onInitCallbacks: Map<string, Set<OnInitCallBack<T>>> = new Map();\n\n  constructor(\n    private readonly name: T,\n    private readonly container: ComponentContainer\n  ) {}\n\n  /**\n   * @param identifier A provider can provide multiple instances of a service\n   * if this.component.multipleInstances is true.\n   */\n  get(identifier?: string): Promise<NameServiceMapping[T]> {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n\n    if (!this.instancesDeferred.has(normalizedIdentifier)) {\n      const deferred = new Deferred<NameServiceMapping[T]>();\n      this.instancesDeferred.set(normalizedIdentifier, deferred);\n\n      if (\n        this.isInitialized(normalizedIdentifier) ||\n        this.shouldAutoInitialize()\n      ) {\n        // initialize the service if it can be auto-initialized\n        try {\n          const instance = this.getOrInitializeService({\n            instanceIdentifier: normalizedIdentifier\n          });\n          if (instance) {\n            deferred.resolve(instance);\n          }\n        } catch (e) {\n          // when the instance factory throws an exception during get(), it should not cause\n          // a fatal error. We just return the unresolved promise in this case.\n        }\n      }\n    }\n\n    return this.instancesDeferred.get(normalizedIdentifier)!.promise;\n  }\n\n  /**\n   *\n   * @param options.identifier A provider can provide multiple instances of a service\n   * if this.component.multipleInstances is true.\n   * @param options.optional If optional is false or not provided, the method throws an error when\n   * the service is not immediately available.\n   * If optional is true, the method returns null if the service is not immediately available.\n   */\n  getImmediate(options: {\n    identifier?: string;\n    optional: true;\n  }): NameServiceMapping[T] | null;\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: false;\n  }): NameServiceMapping[T];\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: boolean;\n  }): NameServiceMapping[T] | null {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      options?.identifier\n    );\n    const optional = options?.optional ?? false;\n\n    if (\n      this.isInitialized(normalizedIdentifier) ||\n      this.shouldAutoInitialize()\n    ) {\n      try {\n        return this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        });\n      } catch (e) {\n        if (optional) {\n          return null;\n        } else {\n          throw e;\n        }\n      }\n    } else {\n      // In case a component is not initialized and should/cannot be auto-initialized at the moment, return null if the optional flag is set, or throw\n      if (optional) {\n        return null;\n      } else {\n        throw Error(`Service ${this.name} is not available`);\n      }\n    }\n  }\n\n  getComponent(): Component<T> | null {\n    return this.component;\n  }\n\n  setComponent(component: Component<T>): void {\n    if (component.name !== this.name) {\n      throw Error(\n        `Mismatching Component ${component.name} for Provider ${this.name}.`\n      );\n    }\n\n    if (this.component) {\n      throw Error(`Component for ${this.name} has already been provided`);\n    }\n\n    this.component = component;\n\n    // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`)\n    if (!this.shouldAutoInitialize()) {\n      return;\n    }\n\n    // if the service is eager, initialize the default instance\n    if (isComponentEager(component)) {\n      try {\n        this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });\n      } catch (e) {\n        // when the instance factory for an eager Component throws an exception during the eager\n        // initialization, it should not cause a fatal error.\n        // TODO: Investigate if we need to make it configurable, because some component may want to cause\n        // a fatal error in this case?\n      }\n    }\n\n    // Create service instances for the pending promises and resolve them\n    // NOTE: if this.multipleInstances is false, only the default instance will be created\n    // and all promises with resolve with it regardless of the identifier.\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n\n      try {\n        // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.\n        const instance = this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        })!;\n        instanceDeferred.resolve(instance);\n      } catch (e) {\n        // when the instance factory throws an exception, it should not cause\n        // a fatal error. We just leave the promise unresolved.\n      }\n    }\n  }\n\n  clearInstance(identifier: string = DEFAULT_ENTRY_NAME): void {\n    this.instancesDeferred.delete(identifier);\n    this.instancesOptions.delete(identifier);\n    this.instances.delete(identifier);\n  }\n\n  // app.delete() will call this method on every provider to delete the services\n  // TODO: should we mark the provider as deleted?\n  async delete(): Promise<void> {\n    const services = Array.from(this.instances.values());\n\n    await Promise.all([\n      ...services\n        .filter(service => 'INTERNAL' in service) // legacy services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any).INTERNAL!.delete()),\n      ...services\n        .filter(service => '_delete' in service) // modularized services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any)._delete())\n    ]);\n  }\n\n  isComponentSet(): boolean {\n    return this.component != null;\n  }\n\n  isInitialized(identifier: string = DEFAULT_ENTRY_NAME): boolean {\n    return this.instances.has(identifier);\n  }\n\n  getOptions(identifier: string = DEFAULT_ENTRY_NAME): Record<string, unknown> {\n    return this.instancesOptions.get(identifier) || {};\n  }\n\n  initialize(opts: InitializeOptions = {}): NameServiceMapping[T] {\n    const { options = {} } = opts;\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      opts.instanceIdentifier\n    );\n    if (this.isInitialized(normalizedIdentifier)) {\n      throw Error(\n        `${this.name}(${normalizedIdentifier}) has already been initialized`\n      );\n    }\n\n    if (!this.isComponentSet()) {\n      throw Error(`Component ${this.name} has not been registered yet`);\n    }\n\n    const instance = this.getOrInitializeService({\n      instanceIdentifier: normalizedIdentifier,\n      options\n    })!;\n\n    // resolve any pending promise waiting for the service instance\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedDeferredIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n      if (normalizedIdentifier === normalizedDeferredIdentifier) {\n        instanceDeferred.resolve(instance);\n      }\n    }\n\n    return instance;\n  }\n\n  /**\n   *\n   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().\n   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.\n   *\n   * @param identifier An optional instance identifier\n   * @returns a function to unregister the callback\n   */\n  onInit(callback: OnInitCallBack<T>, identifier?: string): () => void {\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    const existingCallbacks =\n      this.onInitCallbacks.get(normalizedIdentifier) ??\n      new Set<OnInitCallBack<T>>();\n    existingCallbacks.add(callback);\n    this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);\n\n    const existingInstance = this.instances.get(normalizedIdentifier);\n    if (existingInstance) {\n      callback(existingInstance, normalizedIdentifier);\n    }\n\n    return () => {\n      existingCallbacks.delete(callback);\n    };\n  }\n\n  /**\n   * Invoke onInit callbacks synchronously\n   * @param instance the service instance`\n   */\n  private invokeOnInitCallbacks(\n    instance: NameServiceMapping[T],\n    identifier: string\n  ): void {\n    const callbacks = this.onInitCallbacks.get(identifier);\n    if (!callbacks) {\n      return;\n    }\n    for (const callback of callbacks) {\n      try {\n        callback(instance, identifier);\n      } catch {\n        // ignore errors in the onInit callback\n      }\n    }\n  }\n\n  private getOrInitializeService({\n    instanceIdentifier,\n    options = {}\n  }: {\n    instanceIdentifier: string;\n    options?: Record<string, unknown>;\n  }): NameServiceMapping[T] | null {\n    let instance = this.instances.get(instanceIdentifier);\n    if (!instance && this.component) {\n      instance = this.component.instanceFactory(this.container, {\n        instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),\n        options\n      });\n      this.instances.set(instanceIdentifier, instance!);\n      this.instancesOptions.set(instanceIdentifier, options);\n\n      /**\n       * Invoke onInit listeners.\n       * Note this.component.onInstanceCreated is different, which is used by the component creator,\n       * while onInit listeners are registered by consumers of the provider.\n       */\n      this.invokeOnInitCallbacks(instance!, instanceIdentifier);\n\n      /**\n       * Order is important\n       * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which\n       * makes `isInitialized()` return true.\n       */\n      if (this.component.onInstanceCreated) {\n        try {\n          this.component.onInstanceCreated(\n            this.container,\n            instanceIdentifier,\n            instance!\n          );\n        } catch {\n          // ignore errors in the onInstanceCreatedCallback\n        }\n      }\n    }\n\n    return instance || null;\n  }\n\n  private normalizeInstanceIdentifier(\n    identifier: string = DEFAULT_ENTRY_NAME\n  ): string {\n    if (this.component) {\n      return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;\n    } else {\n      return identifier; // assume multiple instances are supported before the component is provided.\n    }\n  }\n\n  private shouldAutoInitialize(): boolean {\n    return (\n      !!this.component &&\n      this.component.instantiationMode !== InstantiationMode.EXPLICIT\n    );\n  }\n}\n\n// undefined should be passed to the service factory for the default instance\nfunction normalizeIdentifierForFactory(identifier: string): string | undefined {\n  return identifier === DEFAULT_ENTRY_NAME ? undefined : identifier;\n}\n\nfunction isComponentEager<T extends Name>(component: Component<T>): boolean {\n  return component.instantiationMode === InstantiationMode.EAGER;\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Provider } from './provider';\nimport { Component } from './component';\nimport { Name } from './types';\n\n/**\n * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal`\n */\nexport class ComponentContainer {\n  private readonly providers = new Map<string, Provider<Name>>();\n\n  constructor(private readonly name: string) {}\n\n  /**\n   *\n   * @param component Component being added\n   * @param overwrite When a component with the same name has already been registered,\n   * if overwrite is true: overwrite the existing component with the new component and create a new\n   * provider with the new component. It can be useful in tests where you want to use different mocks\n   * for different tests.\n   * if overwrite is false: throw an exception\n   */\n  addComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      throw new Error(\n        `Component ${component.name} has already been registered with ${this.name}`\n      );\n    }\n\n    provider.setComponent(component);\n  }\n\n  addOrOverwriteComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      // delete the existing provider from the container, so we can register the new component\n      this.providers.delete(component.name);\n    }\n\n    this.addComponent(component);\n  }\n\n  /**\n   * getProvider provides a type safe interface where it can only be called with a field name\n   * present in NameServiceMapping interface.\n   *\n   * Firebase SDKs providing services should extend NameServiceMapping interface to register\n   * themselves.\n   */\n  getProvider<T extends Name>(name: T): Provider<T> {\n    if (this.providers.has(name)) {\n      return this.providers.get(name) as unknown as Provider<T>;\n    }\n\n    // create a Provider for a service that hasn't registered with Firebase\n    const provider = new Provider<T>(name, this);\n    this.providers.set(name, provider as unknown as Provider<Name>);\n\n    return provider as Provider<T>;\n  }\n\n  getProviders(): Array<Provider<Name>> {\n    return Array.from(this.providers.values());\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type LogLevelString =\n  | 'debug'\n  | 'verbose'\n  | 'info'\n  | 'warn'\n  | 'error'\n  | 'silent';\n\nexport interface LogOptions {\n  level: LogLevelString;\n}\n\nexport type LogCallback = (callbackParams: LogCallbackParams) => void;\n\nexport interface LogCallbackParams {\n  level: LogLevelString;\n  message: string;\n  args: unknown[];\n  type: string;\n}\n\n/**\n * A container for all of the Logger instances\n */\nexport const instances: Logger[] = [];\n\n/**\n * The JS SDK supports 5 log levels and also allows a user the ability to\n * silence the logs altogether.\n *\n * The order is a follows:\n * DEBUG < VERBOSE < INFO < WARN < ERROR\n *\n * All of the log types above the current log level will be captured (i.e. if\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\n * `VERBOSE` logs will not)\n */\nexport enum LogLevel {\n  DEBUG,\n  VERBOSE,\n  INFO,\n  WARN,\n  ERROR,\n  SILENT\n}\n\nconst levelStringToEnum: { [key in LogLevelString]: LogLevel } = {\n  'debug': LogLevel.DEBUG,\n  'verbose': LogLevel.VERBOSE,\n  'info': LogLevel.INFO,\n  'warn': LogLevel.WARN,\n  'error': LogLevel.ERROR,\n  'silent': LogLevel.SILENT\n};\n\n/**\n * The default log level\n */\nconst defaultLogLevel: LogLevel = LogLevel.INFO;\n\n/**\n * We allow users the ability to pass their own log handler. We will pass the\n * type of log, the current log level, and any other arguments passed (i.e. the\n * messages that the user wants to log) to this function.\n */\nexport type LogHandler = (\n  loggerInstance: Logger,\n  logType: LogLevel,\n  ...args: unknown[]\n) => void;\n\n/**\n * By default, `console.debug` is not displayed in the developer console (in\n * chrome). To avoid forcing users to have to opt-in to these logs twice\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\n * logs to the `console.log` function.\n */\nconst ConsoleMethod = {\n  [LogLevel.DEBUG]: 'log',\n  [LogLevel.VERBOSE]: 'log',\n  [LogLevel.INFO]: 'info',\n  [LogLevel.WARN]: 'warn',\n  [LogLevel.ERROR]: 'error'\n};\n\n/**\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\n * messages on to their corresponding console counterparts (if the log method\n * is supported by the current log level)\n */\nconst defaultLogHandler: LogHandler = (instance, logType, ...args): void => {\n  if (logType < instance.logLevel) {\n    return;\n  }\n  const now = new Date().toISOString();\n  const method = ConsoleMethod[logType as keyof typeof ConsoleMethod];\n  if (method) {\n    console[method as 'log' | 'info' | 'warn' | 'error'](\n      `[${now}]  ${instance.name}:`,\n      ...args\n    );\n  } else {\n    throw new Error(\n      `Attempted to log a message with an invalid logType (value: ${logType})`\n    );\n  }\n};\n\nexport class Logger {\n  /**\n   * Gives you an instance of a Logger to capture messages according to\n   * Firebase's logging scheme.\n   *\n   * @param name The name that the logs will be associated with\n   */\n  constructor(public name: string) {\n    /**\n     * Capture the current instance for later use\n     */\n    instances.push(this);\n  }\n\n  /**\n   * The log level of the given Logger instance.\n   */\n  private _logLevel = defaultLogLevel;\n\n  get logLevel(): LogLevel {\n    return this._logLevel;\n  }\n\n  set logLevel(val: LogLevel) {\n    if (!(val in LogLevel)) {\n      throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``);\n    }\n    this._logLevel = val;\n  }\n\n  // Workaround for setter/getter having to be the same type.\n  setLogLevel(val: LogLevel | LogLevelString): void {\n    this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;\n  }\n\n  /**\n   * The main (internal) log handler for the Logger instance.\n   * Can be set to a new function in internal package code but not by user.\n   */\n  private _logHandler: LogHandler = defaultLogHandler;\n  get logHandler(): LogHandler {\n    return this._logHandler;\n  }\n  set logHandler(val: LogHandler) {\n    if (typeof val !== 'function') {\n      throw new TypeError('Value assigned to `logHandler` must be a function');\n    }\n    this._logHandler = val;\n  }\n\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  private _userLogHandler: LogHandler | null = null;\n  get userLogHandler(): LogHandler | null {\n    return this._userLogHandler;\n  }\n  set userLogHandler(val: LogHandler | null) {\n    this._userLogHandler = val;\n  }\n\n  /**\n   * The functions below are all based on the `console` interface\n   */\n\n  debug(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);\n    this._logHandler(this, LogLevel.DEBUG, ...args);\n  }\n  log(...args: unknown[]): void {\n    this._userLogHandler &&\n      this._userLogHandler(this, LogLevel.VERBOSE, ...args);\n    this._logHandler(this, LogLevel.VERBOSE, ...args);\n  }\n  info(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);\n    this._logHandler(this, LogLevel.INFO, ...args);\n  }\n  warn(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);\n    this._logHandler(this, LogLevel.WARN, ...args);\n  }\n  error(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);\n    this._logHandler(this, LogLevel.ERROR, ...args);\n  }\n}\n\nexport function setLogLevel(level: LogLevelString | LogLevel): void {\n  instances.forEach(inst => {\n    inst.setLogLevel(level);\n  });\n}\n\nexport function setUserLogHandler(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  for (const instance of instances) {\n    let customLogLevel: LogLevel | null = null;\n    if (options && options.level) {\n      customLogLevel = levelStringToEnum[options.level];\n    }\n    if (logCallback === null) {\n      instance.userLogHandler = null;\n    } else {\n      instance.userLogHandler = (\n        instance: Logger,\n        level: LogLevel,\n        ...args: unknown[]\n      ) => {\n        const message = args\n          .map(arg => {\n            if (arg == null) {\n              return null;\n            } else if (typeof arg === 'string') {\n              return arg;\n            } else if (typeof arg === 'number' || typeof arg === 'boolean') {\n              return arg.toString();\n            } else if (arg instanceof Error) {\n              return arg.message;\n            } else {\n              try {\n                return JSON.stringify(arg);\n              } catch (ignored) {\n                return null;\n              }\n            }\n          })\n          .filter(arg => arg)\n          .join(' ');\n        if (level >= (customLogLevel ?? instance.logLevel)) {\n          logCallback({\n            level: LogLevel[level].toLowerCase() as LogLevelString,\n            message,\n            args,\n            type: instance.name\n          });\n        }\n      };\n    }\n  }\n}\n", "const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);\n\nlet idbProxyableTypes;\nlet cursorAdvanceMethods;\n// This is a function to prevent it throwing up in node environments.\nfunction getIdbProxyableTypes() {\n    return (idbProxyableTypes ||\n        (idbProxyableTypes = [\n            IDBDatabase,\n            IDBObjectStore,\n            IDBIndex,\n            IDBCursor,\n            IDBTransaction,\n        ]));\n}\n// This is a function to prevent it throwing up in node environments.\nfunction getCursorAdvanceMethods() {\n    return (cursorAdvanceMethods ||\n        (cursorAdvanceMethods = [\n            IDBCursor.prototype.advance,\n            IDBCursor.prototype.continue,\n            IDBCursor.prototype.continuePrimaryKey,\n        ]));\n}\nconst cursorRequestMap = new WeakMap();\nconst transactionDoneMap = new WeakMap();\nconst transactionStoreNamesMap = new WeakMap();\nconst transformCache = new WeakMap();\nconst reverseTransformCache = new WeakMap();\nfunction promisifyRequest(request) {\n    const promise = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            request.removeEventListener('success', success);\n            request.removeEventListener('error', error);\n        };\n        const success = () => {\n            resolve(wrap(request.result));\n            unlisten();\n        };\n        const error = () => {\n            reject(request.error);\n            unlisten();\n        };\n        request.addEventListener('success', success);\n        request.addEventListener('error', error);\n    });\n    promise\n        .then((value) => {\n        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval\n        // (see wrapFunction).\n        if (value instanceof IDBCursor) {\n            cursorRequestMap.set(value, request);\n        }\n        // Catching to avoid \"Uncaught Promise exceptions\"\n    })\n        .catch(() => { });\n    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This\n    // is because we create many promises from a single IDBRequest.\n    reverseTransformCache.set(promise, request);\n    return promise;\n}\nfunction cacheDonePromiseForTransaction(tx) {\n    // Early bail if we've already created a done promise for this transaction.\n    if (transactionDoneMap.has(tx))\n        return;\n    const done = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            tx.removeEventListener('complete', complete);\n            tx.removeEventListener('error', error);\n            tx.removeEventListener('abort', error);\n        };\n        const complete = () => {\n            resolve();\n            unlisten();\n        };\n        const error = () => {\n            reject(tx.error || new DOMException('AbortError', 'AbortError'));\n            unlisten();\n        };\n        tx.addEventListener('complete', complete);\n        tx.addEventListener('error', error);\n        tx.addEventListener('abort', error);\n    });\n    // Cache it for later retrieval.\n    transactionDoneMap.set(tx, done);\n}\nlet idbProxyTraps = {\n    get(target, prop, receiver) {\n        if (target instanceof IDBTransaction) {\n            // Special handling for transaction.done.\n            if (prop === 'done')\n                return transactionDoneMap.get(target);\n            // Polyfill for objectStoreNames because of Edge.\n            if (prop === 'objectStoreNames') {\n                return target.objectStoreNames || transactionStoreNamesMap.get(target);\n            }\n            // Make tx.store return the only store in the transaction, or undefined if there are many.\n            if (prop === 'store') {\n                return receiver.objectStoreNames[1]\n                    ? undefined\n                    : receiver.objectStore(receiver.objectStoreNames[0]);\n            }\n        }\n        // Else transform whatever we get back.\n        return wrap(target[prop]);\n    },\n    set(target, prop, value) {\n        target[prop] = value;\n        return true;\n    },\n    has(target, prop) {\n        if (target instanceof IDBTransaction &&\n            (prop === 'done' || prop === 'store')) {\n            return true;\n        }\n        return prop in target;\n    },\n};\nfunction replaceTraps(callback) {\n    idbProxyTraps = callback(idbProxyTraps);\n}\nfunction wrapFunction(func) {\n    // Due to expected object equality (which is enforced by the caching in `wrap`), we\n    // only create one new func per func.\n    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.\n    if (func === IDBDatabase.prototype.transaction &&\n        !('objectStoreNames' in IDBTransaction.prototype)) {\n        return function (storeNames, ...args) {\n            const tx = func.call(unwrap(this), storeNames, ...args);\n            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);\n            return wrap(tx);\n        };\n    }\n    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In\n    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the\n    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense\n    // with real promises, so each advance methods returns a new promise for the cursor object, or\n    // undefined if the end of the cursor has been reached.\n    if (getCursorAdvanceMethods().includes(func)) {\n        return function (...args) {\n            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n            // the original object.\n            func.apply(unwrap(this), args);\n            return wrap(cursorRequestMap.get(this));\n        };\n    }\n    return function (...args) {\n        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n        // the original object.\n        return wrap(func.apply(unwrap(this), args));\n    };\n}\nfunction transformCachableValue(value) {\n    if (typeof value === 'function')\n        return wrapFunction(value);\n    // This doesn't return, it just creates a 'done' promise for the transaction,\n    // which is later returned for transaction.done (see idbObjectHandler).\n    if (value instanceof IDBTransaction)\n        cacheDonePromiseForTransaction(value);\n    if (instanceOfAny(value, getIdbProxyableTypes()))\n        return new Proxy(value, idbProxyTraps);\n    // Return the same value back if we're not going to transform it.\n    return value;\n}\nfunction wrap(value) {\n    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because\n    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.\n    if (value instanceof IDBRequest)\n        return promisifyRequest(value);\n    // If we've already transformed this value before, reuse the transformed value.\n    // This is faster, but it also provides object equality.\n    if (transformCache.has(value))\n        return transformCache.get(value);\n    const newValue = transformCachableValue(value);\n    // Not all types are transformed.\n    // These may be primitive types, so they can't be WeakMap keys.\n    if (newValue !== value) {\n        transformCache.set(value, newValue);\n        reverseTransformCache.set(newValue, value);\n    }\n    return newValue;\n}\nconst unwrap = (value) => reverseTransformCache.get(value);\n\nexport { reverseTransformCache as a, instanceOfAny as i, replaceTraps as r, unwrap as u, wrap as w };\n", "import { w as wrap, r as replaceTraps } from './wrap-idb-value.js';\nexport { u as unwrap, w as wrap } from './wrap-idb-value.js';\n\n/**\n * Open a database.\n *\n * @param name Name of the database.\n * @param version Schema version.\n * @param callbacks Additional callbacks.\n */\nfunction openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {\n    const request = indexedDB.open(name, version);\n    const openPromise = wrap(request);\n    if (upgrade) {\n        request.addEventListener('upgradeneeded', (event) => {\n            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);\n        });\n    }\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event.newVersion, event));\n    }\n    openPromise\n        .then((db) => {\n        if (terminated)\n            db.addEventListener('close', () => terminated());\n        if (blocking) {\n            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));\n        }\n    })\n        .catch(() => { });\n    return openPromise;\n}\n/**\n * Delete a database.\n *\n * @param name Name of the database.\n */\nfunction deleteDB(name, { blocked } = {}) {\n    const request = indexedDB.deleteDatabase(name);\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event));\n    }\n    return wrap(request).then(() => undefined);\n}\n\nconst readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];\nconst writeMethods = ['put', 'add', 'delete', 'clear'];\nconst cachedMethods = new Map();\nfunction getMethod(target, prop) {\n    if (!(target instanceof IDBDatabase &&\n        !(prop in target) &&\n        typeof prop === 'string')) {\n        return;\n    }\n    if (cachedMethods.get(prop))\n        return cachedMethods.get(prop);\n    const targetFuncName = prop.replace(/FromIndex$/, '');\n    const useIndex = prop !== targetFuncName;\n    const isWrite = writeMethods.includes(targetFuncName);\n    if (\n    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.\n    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||\n        !(isWrite || readMethods.includes(targetFuncName))) {\n        return;\n    }\n    const method = async function (storeName, ...args) {\n        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(\n        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');\n        let target = tx.store;\n        if (useIndex)\n            target = target.index(args.shift());\n        // Must reject if op rejects.\n        // If it's a write operation, must reject if tx.done rejects.\n        // Must reject with op rejection first.\n        // Must resolve with op value.\n        // Must handle both promises (no unhandled rejections)\n        return (await Promise.all([\n            target[targetFuncName](...args),\n            isWrite && tx.done,\n        ]))[0];\n    };\n    cachedMethods.set(prop, method);\n    return method;\n}\nreplaceTraps((oldTraps) => ({\n    ...oldTraps,\n    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),\n    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),\n}));\n\nexport { deleteDB, openDB };\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ComponentContainer,\n  ComponentType,\n  Provider,\n  Name\n} from '@firebase/component';\nimport { PlatformLoggerService, VersionService } from './types';\n\nexport class PlatformLoggerServiceImpl implements PlatformLoggerService {\n  constructor(private readonly container: ComponentContainer) {}\n  // In initial implementation, this will be called by installations on\n  // auth token refresh, and installations will send this string.\n  getPlatformInfoString(): string {\n    const providers = this.container.getProviders();\n    // Loop through providers and get library/version pairs from any that are\n    // version components.\n    return providers\n      .map(provider => {\n        if (isVersionServiceProvider(provider)) {\n          const service = provider.getImmediate() as VersionService;\n          return `${service.library}/${service.version}`;\n        } else {\n          return null;\n        }\n      })\n      .filter(logString => logString)\n      .join(' ');\n  }\n}\n/**\n *\n * @param provider check if this provider provides a VersionService\n *\n * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider\n * provides VersionService. The provider is not necessarily a 'app-version'\n * provider.\n */\nfunction isVersionServiceProvider(provider: Provider<Name>): boolean {\n  const component = provider.getComponent();\n  return component?.type === ComponentType.VERSION;\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger } from '@firebase/logger';\n\nexport const logger = new Logger('@firebase/app');\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { name as appName } from '../package.json';\nimport { name as appCompatName } from '../../app-compat/package.json';\nimport { name as analyticsCompatName } from '../../../packages/analytics-compat/package.json';\nimport { name as analyticsName } from '../../../packages/analytics/package.json';\nimport { name as appCheckCompatName } from '../../../packages/app-check-compat/package.json';\nimport { name as appCheckName } from '../../../packages/app-check/package.json';\nimport { name as authName } from '../../../packages/auth/package.json';\nimport { name as authCompatName } from '../../../packages/auth-compat/package.json';\nimport { name as databaseName } from '../../../packages/database/package.json';\nimport { name as dataconnectName } from '../../../packages/data-connect/package.json';\nimport { name as databaseCompatName } from '../../../packages/database-compat/package.json';\nimport { name as functionsName } from '../../../packages/functions/package.json';\nimport { name as functionsCompatName } from '../../../packages/functions-compat/package.json';\nimport { name as installationsName } from '../../../packages/installations/package.json';\nimport { name as installationsCompatName } from '../../../packages/installations-compat/package.json';\nimport { name as messagingName } from '../../../packages/messaging/package.json';\nimport { name as messagingCompatName } from '../../../packages/messaging-compat/package.json';\nimport { name as performanceName } from '../../../packages/performance/package.json';\nimport { name as performanceCompatName } from '../../../packages/performance-compat/package.json';\nimport { name as remoteConfigName } from '../../../packages/remote-config/package.json';\nimport { name as remoteConfigCompatName } from '../../../packages/remote-config-compat/package.json';\nimport { name as storageName } from '../../../packages/storage/package.json';\nimport { name as storageCompatName } from '../../../packages/storage-compat/package.json';\nimport { name as firestoreName } from '../../../packages/firestore/package.json';\nimport { name as aiName } from '../../../packages/ai/package.json';\nimport { name as firestoreCompatName } from '../../../packages/firestore-compat/package.json';\nimport { name as packageName } from '../../../packages/firebase/package.json';\n\n/**\n * The default app name\n *\n * @internal\n */\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\n\nexport const PLATFORM_LOG_STRING = {\n  [appName]: 'fire-core',\n  [appCompatName]: 'fire-core-compat',\n  [analyticsName]: 'fire-analytics',\n  [analyticsCompatName]: 'fire-analytics-compat',\n  [appCheckName]: 'fire-app-check',\n  [appCheckCompatName]: 'fire-app-check-compat',\n  [authName]: 'fire-auth',\n  [authCompatName]: 'fire-auth-compat',\n  [databaseName]: 'fire-rtdb',\n  [dataconnectName]: 'fire-data-connect',\n  [databaseCompatName]: 'fire-rtdb-compat',\n  [functionsName]: 'fire-fn',\n  [functionsCompatName]: 'fire-fn-compat',\n  [installationsName]: 'fire-iid',\n  [installationsCompatName]: 'fire-iid-compat',\n  [messagingName]: 'fire-fcm',\n  [messagingCompatName]: 'fire-fcm-compat',\n  [performanceName]: 'fire-perf',\n  [performanceCompatName]: 'fire-perf-compat',\n  [remoteConfigName]: 'fire-rc',\n  [remoteConfigCompatName]: 'fire-rc-compat',\n  [storageName]: 'fire-gcs',\n  [storageCompatName]: 'fire-gcs-compat',\n  [firestoreName]: 'fire-fst',\n  [firestoreCompatName]: 'fire-fst-compat',\n  [aiName]: 'fire-vertex',\n  'fire-js': 'fire-js', // Platform identifier for JS SDK.\n  [packageName]: 'fire-js-all'\n} as const;\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseAppSettings,\n  FirebaseServerAppSettings,\n  FirebaseOptions,\n  FirebaseServerApp\n} from './public-types';\nimport { Component, Provider, Name } from '@firebase/component';\nimport { logger } from './logger';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { FirebaseServerAppImpl } from './firebaseServerApp';\n\n/**\n * @internal\n */\nexport const _apps = new Map<string, FirebaseApp>();\n\n/**\n * @internal\n */\nexport const _serverApps = new Map<string, FirebaseServerApp>();\n\n/**\n * Registered components.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const _components = new Map<string, Component<any>>();\n\n/**\n * @param component - the component being added to this app's container\n *\n * @internal\n */\nexport function _addComponent<T extends Name>(\n  app: FirebaseApp,\n  component: Component<T>\n): void {\n  try {\n    (app as FirebaseAppImpl).container.addComponent(component);\n  } catch (e) {\n    logger.debug(\n      `Component ${component.name} failed to register with FirebaseApp ${app.name}`,\n      e\n    );\n  }\n}\n\n/**\n *\n * @internal\n */\nexport function _addOrOverwriteComponent(\n  app: FirebaseApp,\n  component: Component\n): void {\n  (app as FirebaseAppImpl).container.addOrOverwriteComponent(component);\n}\n\n/**\n *\n * @param component - the component to register\n * @returns whether or not the component is registered successfully\n *\n * @internal\n */\nexport function _registerComponent<T extends Name>(\n  component: Component<T>\n): boolean {\n  const componentName = component.name;\n  if (_components.has(componentName)) {\n    logger.debug(\n      `There were multiple attempts to register component ${componentName}.`\n    );\n\n    return false;\n  }\n\n  _components.set(componentName, component);\n\n  // add the component to existing app instances\n  for (const app of _apps.values()) {\n    _addComponent(app as FirebaseAppImpl, component);\n  }\n\n  for (const serverApp of _serverApps.values()) {\n    _addComponent(serverApp as FirebaseServerAppImpl, component);\n  }\n\n  return true;\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n *\n * @returns the provider for the service with the matching name\n *\n * @internal\n */\nexport function _getProvider<T extends Name>(\n  app: FirebaseApp,\n  name: T\n): Provider<T> {\n  const heartbeatController = (app as FirebaseAppImpl).container\n    .getProvider('heartbeat')\n    .getImmediate({ optional: true });\n  if (heartbeatController) {\n    void heartbeatController.triggerHeartbeat();\n  }\n  return (app as FirebaseAppImpl).container.getProvider(name);\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n * @param instanceIdentifier - service instance identifier in case the service supports multiple instances\n *\n * @internal\n */\nexport function _removeServiceInstance<T extends Name>(\n  app: FirebaseApp,\n  name: T,\n  instanceIdentifier: string = DEFAULT_ENTRY_NAME\n): void {\n  _getProvider(app, name).clearInstance(instanceIdentifier);\n}\n\n/**\n *\n * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.\n *\n * @returns true if the provide object is of type FirebaseApp.\n *\n * @internal\n */\nexport function _isFirebaseApp(\n  obj: FirebaseApp | FirebaseOptions | FirebaseAppSettings\n): obj is FirebaseApp {\n  return (obj as FirebaseApp).options !== undefined;\n}\n\n/**\n *\n * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.\n *\n * @returns true if the provided object is of type FirebaseServerAppImpl.\n *\n * @internal\n */\nexport function _isFirebaseServerAppSettings(\n  obj: FirebaseApp | FirebaseOptions | FirebaseAppSettings\n): obj is FirebaseServerAppSettings {\n  if (_isFirebaseApp(obj)) {\n    return false;\n  }\n  return (\n    'authIdToken' in obj ||\n    'appCheckToken' in obj ||\n    'releaseOnDeref' in obj ||\n    'automaticDataCollectionEnabled' in obj\n  );\n}\n\n/**\n *\n * @param obj - an object of type FirebaseApp.\n *\n * @returns true if the provided object is of type FirebaseServerAppImpl.\n *\n * @internal\n */\nexport function _isFirebaseServerApp(\n  obj: FirebaseApp | FirebaseServerApp | null | undefined\n): obj is FirebaseServerApp {\n  if (obj === null || obj === undefined) {\n    return false;\n  }\n  return (obj as FirebaseServerApp).settings !== undefined;\n}\n\n/**\n * Test only\n *\n * @internal\n */\nexport function _clearComponents(): void {\n  _components.clear();\n}\n\n/**\n * Exported in order to be used in app-compat package\n */\nexport { DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME };\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum AppError {\n  NO_APP = 'no-app',\n  BAD_APP_NAME = 'bad-app-name',\n  DUPLICATE_APP = 'duplicate-app',\n  APP_DELETED = 'app-deleted',\n  SERVER_APP_DELETED = 'server-app-deleted',\n  NO_OPTIONS = 'no-options',\n  INVALID_APP_ARGUMENT = 'invalid-app-argument',\n  INVALID_LOG_ARGUMENT = 'invalid-log-argument',\n  IDB_OPEN = 'idb-open',\n  IDB_GET = 'idb-get',\n  IDB_WRITE = 'idb-set',\n  IDB_DELETE = 'idb-delete',\n  FINALIZATION_REGISTRY_NOT_SUPPORTED = 'finalization-registry-not-supported',\n  INVALID_SERVER_APP_ENVIRONMENT = 'invalid-server-app-environment'\n}\n\nconst ERRORS: ErrorMap<AppError> = {\n  [AppError.NO_APP]:\n    \"No Firebase App '{$appName}' has been created - \" +\n    'call initializeApp() first',\n  [AppError.BAD_APP_NAME]: \"Illegal App name: '{$appName}'\",\n  [AppError.DUPLICATE_APP]:\n    \"Firebase App named '{$appName}' already exists with different options or config\",\n  [AppError.APP_DELETED]: \"Firebase App named '{$appName}' already deleted\",\n  [AppError.SERVER_APP_DELETED]: 'Firebase Server App has been deleted',\n  [AppError.NO_OPTIONS]:\n    'Need to provide options, when not being deployed to hosting via source.',\n  [AppError.INVALID_APP_ARGUMENT]:\n    'firebase.{$appName}() takes either no argument or a ' +\n    'Firebase App instance.',\n  [AppError.INVALID_LOG_ARGUMENT]:\n    'First argument to `onLog` must be null or a function.',\n  [AppError.IDB_OPEN]:\n    'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_GET]:\n    'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_WRITE]:\n    'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_DELETE]:\n    'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED]:\n    'FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.',\n  [AppError.INVALID_SERVER_APP_ENVIRONMENT]:\n    'FirebaseServerApp is not for use in browser environments.'\n};\n\ninterface ErrorParams {\n  [AppError.NO_APP]: { appName: string };\n  [AppError.BAD_APP_NAME]: { appName: string };\n  [AppError.DUPLICATE_APP]: { appName: string };\n  [AppError.APP_DELETED]: { appName: string };\n  [AppError.INVALID_APP_ARGUMENT]: { appName: string };\n  [AppError.IDB_OPEN]: { originalErrorMessage?: string };\n  [AppError.IDB_GET]: { originalErrorMessage?: string };\n  [AppError.IDB_WRITE]: { originalErrorMessage?: string };\n  [AppError.IDB_DELETE]: { originalErrorMessage?: string };\n  [AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED]: { appName?: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<AppError, ErrorParams>(\n  'app',\n  'Firebase',\n  ERRORS\n);\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppSettings\n} from './public-types';\nimport {\n  ComponentContainer,\n  Component,\n  ComponentType\n} from '@firebase/component';\nimport { ERROR_FACTORY, AppError } from './errors';\n\nexport class FirebaseAppImpl implements FirebaseApp {\n  protected readonly _options: FirebaseOptions;\n  protected readonly _name: string;\n  /**\n   * Original config values passed in as a constructor parameter.\n   * It is only used to compare with another config object to support idempotent initializeApp().\n   *\n   * Updating automaticDataCollectionEnabled on the App instance will not change its value in _config.\n   */\n  private readonly _config: Required<FirebaseAppSettings>;\n  private _automaticDataCollectionEnabled: boolean;\n  protected _isDeleted = false;\n  private readonly _container: ComponentContainer;\n\n  constructor(\n    options: FirebaseOptions,\n    config: Required<FirebaseAppSettings>,\n    container: ComponentContainer\n  ) {\n    this._options = { ...options };\n    this._config = { ...config };\n    this._name = config.name;\n    this._automaticDataCollectionEnabled =\n      config.automaticDataCollectionEnabled;\n    this._container = container;\n    this.container.addComponent(\n      new Component('app', () => this, ComponentType.PUBLIC)\n    );\n  }\n\n  get automaticDataCollectionEnabled(): boolean {\n    this.checkDestroyed();\n    return this._automaticDataCollectionEnabled;\n  }\n\n  set automaticDataCollectionEnabled(val: boolean) {\n    this.checkDestroyed();\n    this._automaticDataCollectionEnabled = val;\n  }\n\n  get name(): string {\n    this.checkDestroyed();\n    return this._name;\n  }\n\n  get options(): FirebaseOptions {\n    this.checkDestroyed();\n    return this._options;\n  }\n\n  get config(): Required<FirebaseAppSettings> {\n    this.checkDestroyed();\n    return this._config;\n  }\n\n  get container(): ComponentContainer {\n    return this._container;\n  }\n\n  get isDeleted(): boolean {\n    return this._isDeleted;\n  }\n\n  set isDeleted(val: boolean) {\n    this._isDeleted = val;\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  protected checkDestroyed(): void {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(AppError.APP_DELETED, { appName: this._name });\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseAppSettings,\n  FirebaseServerApp,\n  FirebaseServerAppSettings,\n  FirebaseOptions\n} from './public-types';\nimport { deleteApp, registerVersion } from './api';\nimport { ComponentContainer } from '@firebase/component';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport { name as packageName, version } from '../package.json';\nimport { base64Decode } from '@firebase/util';\n\n// Parse the token and check to see if the `exp` claim is in the future.\n// Reports an error to the console if the token or claim could not be parsed, or if `exp` is in\n// the past.\nfunction validateTokenTTL(base64Token: string, tokenName: string): void {\n  const secondPart = base64Decode(base64Token.split('.')[1]);\n  if (secondPart === null) {\n    console.error(\n      `FirebaseServerApp ${tokenName} is invalid: second part could not be parsed.`\n    );\n    return;\n  }\n  const expClaim = JSON.parse(secondPart).exp;\n  if (expClaim === undefined) {\n    console.error(\n      `FirebaseServerApp ${tokenName} is invalid: expiration claim could not be parsed`\n    );\n    return;\n  }\n  const exp = JSON.parse(secondPart).exp * 1000;\n  const now = new Date().getTime();\n  const diff = exp - now;\n  if (diff <= 0) {\n    console.error(\n      `FirebaseServerApp ${tokenName} is invalid: the token has expired.`\n    );\n  }\n}\n\nexport class FirebaseServerAppImpl\n  extends FirebaseAppImpl\n  implements FirebaseServerApp\n{\n  private readonly _serverConfig: FirebaseServerAppSettings;\n  private _finalizationRegistry: FinalizationRegistry<object> | null;\n  private _refCount: number;\n\n  constructor(\n    options: FirebaseOptions | FirebaseAppImpl,\n    serverConfig: FirebaseServerAppSettings,\n    name: string,\n    container: ComponentContainer\n  ) {\n    // Build configuration parameters for the FirebaseAppImpl base class.\n    const automaticDataCollectionEnabled =\n      serverConfig.automaticDataCollectionEnabled !== undefined\n        ? serverConfig.automaticDataCollectionEnabled\n        : true;\n\n    // Create the FirebaseAppSettings object for the FirebaseAppImp constructor.\n    const config: Required<FirebaseAppSettings> = {\n      name,\n      automaticDataCollectionEnabled\n    };\n\n    if ((options as FirebaseOptions).apiKey !== undefined) {\n      // Construct the parent FirebaseAppImp object.\n      super(options as FirebaseOptions, config, container);\n    } else {\n      const appImpl: FirebaseAppImpl = options as FirebaseAppImpl;\n      super(appImpl.options, config, container);\n    }\n\n    // Now construct the data for the FirebaseServerAppImpl.\n    this._serverConfig = {\n      automaticDataCollectionEnabled,\n      ...serverConfig\n    };\n\n    // Ensure that the current time is within the `authIdtoken` window of validity.\n    if (this._serverConfig.authIdToken) {\n      validateTokenTTL(this._serverConfig.authIdToken, 'authIdToken');\n    }\n\n    // Ensure that the current time is within the `appCheckToken` window of validity.\n    if (this._serverConfig.appCheckToken) {\n      validateTokenTTL(this._serverConfig.appCheckToken, 'appCheckToken');\n    }\n\n    this._finalizationRegistry = null;\n    if (typeof FinalizationRegistry !== 'undefined') {\n      this._finalizationRegistry = new FinalizationRegistry(() => {\n        this.automaticCleanup();\n      });\n    }\n\n    this._refCount = 0;\n    this.incRefCount(this._serverConfig.releaseOnDeref);\n\n    // Do not retain a hard reference to the dref object, otherwise the FinalizationRegistry\n    // will never trigger.\n    this._serverConfig.releaseOnDeref = undefined;\n    serverConfig.releaseOnDeref = undefined;\n\n    registerVersion(packageName, version, 'serverapp');\n  }\n\n  toJSON(): undefined {\n    return undefined;\n  }\n\n  get refCount(): number {\n    return this._refCount;\n  }\n\n  // Increment the reference count of this server app. If an object is provided, register it\n  // with the finalization registry.\n  incRefCount(obj: object | undefined): void {\n    if (this.isDeleted) {\n      return;\n    }\n    this._refCount++;\n    if (obj !== undefined && this._finalizationRegistry !== null) {\n      this._finalizationRegistry.register(obj, this);\n    }\n  }\n\n  // Decrement the reference count.\n  decRefCount(): number {\n    if (this.isDeleted) {\n      return 0;\n    }\n    return --this._refCount;\n  }\n\n  // Invoked by the FinalizationRegistry callback to note that this app should go through its\n  // reference counts and delete itself if no reference count remain. The coordinating logic that\n  // handles this is in deleteApp(...).\n  private automaticCleanup(): void {\n    void deleteApp(this);\n  }\n\n  get settings(): FirebaseServerAppSettings {\n    this.checkDestroyed();\n    return this._serverConfig;\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  protected checkDestroyed(): void {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(AppError.SERVER_APP_DELETED);\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseServerApp,\n  FirebaseOptions,\n  FirebaseAppSettings,\n  FirebaseServerAppSettings\n} from './public-types';\nimport { DEFAULT_ENTRY_NAME, PLATFORM_LOG_STRING } from './constants';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport {\n  ComponentContainer,\n  Component,\n  Name,\n  ComponentType\n} from '@firebase/component';\nimport { version } from '../../firebase/package.json';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { FirebaseServerAppImpl } from './firebaseServerApp';\nimport {\n  _apps,\n  _components,\n  _isFirebaseApp,\n  _isFirebaseServerAppSettings,\n  _registerComponent,\n  _serverApps\n} from './internal';\nimport { logger } from './logger';\nimport {\n  LogLevelString,\n  setLogLevel as setLogLevelImpl,\n  LogCallback,\n  LogOptions,\n  setUserLogHandler\n} from '@firebase/logger';\nimport {\n  deepEqual,\n  getDefaultAppConfig,\n  isBrowser,\n  isWebWorker\n} from '@firebase/util';\n\nexport { FirebaseError } from '@firebase/util';\n\n/**\n * The current SDK version.\n *\n * @public\n */\nexport const SDK_VERSION = version;\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseApp} instance.\n *\n * See\n * {@link\n *   https://firebase.google.com/docs/web/setup#add_firebase_to_your_app\n *   | Add Firebase to your app} and\n * {@link\n *   https://firebase.google.com/docs/web/setup#multiple-projects\n *   | Initialize multiple projects} for detailed documentation.\n *\n * @example\n * ```javascript\n *\n * // Initialize default app\n * // Retrieve your own options values by adding a web app on\n * // https://console.firebase.google.com\n * initializeApp({\n *   apiKey: \"AIza....\",                             // Auth / General Use\n *   authDomain: \"YOUR_APP.firebaseapp.com\",         // Auth with popup/redirect\n *   databaseURL: \"https://YOUR_APP.firebaseio.com\", // Realtime Database\n *   storageBucket: \"YOUR_APP.appspot.com\",          // Storage\n *   messagingSenderId: \"123456789\"                  // Cloud Messaging\n * });\n * ```\n *\n * @example\n * ```javascript\n *\n * // Initialize another app\n * const otherApp = initializeApp({\n *   databaseURL: \"https://<OTHER_DATABASE_NAME>.firebaseio.com\",\n *   storageBucket: \"<OTHER_STORAGE_BUCKET>.appspot.com\"\n * }, \"otherApp\");\n * ```\n *\n * @param options - Options to configure the app's services.\n * @param name - Optional name of the app to initialize. If no name\n *   is provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The initialized app.\n *\n * @throws If the optional `name` parameter is malformed or empty.\n *\n * @throws If a `FirebaseApp` already exists with the same name but with a different configuration.\n *\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  name?: string\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @param options - Options to configure the app's services.\n * @param config - FirebaseApp Configuration\n *\n * @throws If {@link FirebaseAppSettings.name} is defined but the value is malformed or empty.\n *\n * @throws If a `FirebaseApp` already exists with the same name but with a different configuration.\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  config?: FirebaseAppSettings\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @public\n */\nexport function initializeApp(): FirebaseApp;\nexport function initializeApp(\n  _options?: FirebaseOptions,\n  rawConfig = {}\n): FirebaseApp {\n  let options = _options;\n\n  if (typeof rawConfig !== 'object') {\n    const name = rawConfig;\n    rawConfig = { name };\n  }\n\n  const config: Required<FirebaseAppSettings> = {\n    name: DEFAULT_ENTRY_NAME,\n    automaticDataCollectionEnabled: true,\n    ...rawConfig\n  };\n  const name = config.name;\n\n  if (typeof name !== 'string' || !name) {\n    throw ERROR_FACTORY.create(AppError.BAD_APP_NAME, {\n      appName: String(name)\n    });\n  }\n\n  options ||= getDefaultAppConfig();\n\n  if (!options) {\n    throw ERROR_FACTORY.create(AppError.NO_OPTIONS);\n  }\n\n  const existingApp = _apps.get(name) as FirebaseAppImpl;\n  if (existingApp) {\n    // return the existing app if options and config deep equal the ones in the existing app.\n    if (\n      deepEqual(options, existingApp.options) &&\n      deepEqual(config, existingApp.config)\n    ) {\n      return existingApp;\n    } else {\n      throw ERROR_FACTORY.create(AppError.DUPLICATE_APP, { appName: name });\n    }\n  }\n\n  const container = new ComponentContainer(name);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n\n  const newApp = new FirebaseAppImpl(options, config, container);\n\n  _apps.set(name, newApp);\n\n  return newApp;\n}\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseServerApp} instance.\n *\n * The `FirebaseServerApp` is similar to `FirebaseApp`, but is intended for execution in\n * server side rendering environments only. Initialization will fail if invoked from a\n * browser environment.\n *\n * See\n * {@link\n *   https://firebase.google.com/docs/web/setup#add_firebase_to_your_app\n *   | Add Firebase to your app} and\n * {@link\n *   https://firebase.google.com/docs/web/setup#multiple-projects\n *   | Initialize multiple projects} for detailed documentation.\n *\n * @example\n * ```javascript\n *\n * // Initialize an instance of `FirebaseServerApp`.\n * // Retrieve your own options values by adding a web app on\n * // https://console.firebase.google.com\n * initializeServerApp({\n *     apiKey: \"AIza....\",                             // Auth / General Use\n *     authDomain: \"YOUR_APP.firebaseapp.com\",         // Auth with popup/redirect\n *     databaseURL: \"https://YOUR_APP.firebaseio.com\", // Realtime Database\n *     storageBucket: \"YOUR_APP.appspot.com\",          // Storage\n *     messagingSenderId: \"123456789\"                  // Cloud Messaging\n *   },\n *   {\n *    authIdToken: \"Your Auth ID Token\"\n *   });\n * ```\n *\n * @param options - `Firebase.AppOptions` to configure the app's services, or a\n *   a `FirebaseApp` instance which contains the `AppOptions` within.\n * @param config - Optional `FirebaseServerApp` settings.\n *\n * @returns The initialized `FirebaseServerApp`.\n *\n * @throws If invoked in an unsupported non-server environment such as a browser.\n *\n * @throws If {@link FirebaseServerAppSettings.releaseOnDeref} is defined but the runtime doesn't\n *   provide Finalization Registry support.\n *\n * @public\n */\nexport function initializeServerApp(\n  options: FirebaseOptions | FirebaseApp,\n  config?: FirebaseServerAppSettings\n): FirebaseServerApp;\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseServerApp} instance.\n *\n * @param config - Optional `FirebaseServerApp` settings.\n *\n * @returns The initialized `FirebaseServerApp`.\n *\n * @throws If invoked in an unsupported non-server environment such as a browser.\n * @throws If {@link FirebaseServerAppSettings.releaseOnDeref} is defined but the runtime doesn't\n *   provide Finalization Registry support.\n * @throws If the `FIREBASE_OPTIONS` environment variable does not contain a valid project\n *   configuration required for auto-initialization.\n *\n * @public\n */\nexport function initializeServerApp(\n  config?: FirebaseServerAppSettings\n): FirebaseServerApp;\nexport function initializeServerApp(\n  _options?: FirebaseApp | FirebaseServerAppSettings | FirebaseOptions,\n  _serverAppConfig: FirebaseServerAppSettings = {}\n): FirebaseServerApp {\n  if (isBrowser() && !isWebWorker()) {\n    // FirebaseServerApp isn't designed to be run in browsers.\n    throw ERROR_FACTORY.create(AppError.INVALID_SERVER_APP_ENVIRONMENT);\n  }\n\n  let firebaseOptions: FirebaseOptions | undefined;\n  let serverAppSettings: FirebaseServerAppSettings = _serverAppConfig || {};\n\n  if (_options) {\n    if (_isFirebaseApp(_options)) {\n      firebaseOptions = _options.options;\n    } else if (_isFirebaseServerAppSettings(_options)) {\n      serverAppSettings = _options;\n    } else {\n      firebaseOptions = _options;\n    }\n  }\n\n  if (serverAppSettings.automaticDataCollectionEnabled === undefined) {\n    serverAppSettings.automaticDataCollectionEnabled = true;\n  }\n\n  firebaseOptions ||= getDefaultAppConfig();\n  if (!firebaseOptions) {\n    throw ERROR_FACTORY.create(AppError.NO_OPTIONS);\n  }\n\n  // Build an app name based on a hash of the configuration options.\n  const nameObj = {\n    ...serverAppSettings,\n    ...firebaseOptions\n  };\n\n  // However, Do not mangle the name based on releaseOnDeref, since it will vary between the\n  // construction of FirebaseServerApp instances. For example, if the object is the request headers.\n  if (nameObj.releaseOnDeref !== undefined) {\n    delete nameObj.releaseOnDeref;\n  }\n\n  const hashCode = (s: string): number => {\n    return [...s].reduce(\n      (hash, c) => (Math.imul(31, hash) + c.charCodeAt(0)) | 0,\n      0\n    );\n  };\n\n  if (serverAppSettings.releaseOnDeref !== undefined) {\n    if (typeof FinalizationRegistry === 'undefined') {\n      throw ERROR_FACTORY.create(\n        AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED,\n        {}\n      );\n    }\n  }\n\n  const nameString = '' + hashCode(JSON.stringify(nameObj));\n  const existingApp = _serverApps.get(nameString) as FirebaseServerApp;\n  if (existingApp) {\n    (existingApp as FirebaseServerAppImpl).incRefCount(\n      serverAppSettings.releaseOnDeref\n    );\n    return existingApp;\n  }\n\n  const container = new ComponentContainer(nameString);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n\n  const newApp = new FirebaseServerAppImpl(\n    firebaseOptions,\n    serverAppSettings,\n    nameString,\n    container\n  );\n\n  _serverApps.set(nameString, newApp);\n\n  return newApp;\n}\n\n/**\n * Retrieves a {@link @firebase/app#FirebaseApp} instance.\n *\n * When called with no arguments, the default app is returned. When an app name\n * is provided, the app corresponding to that name is returned.\n *\n * An exception is thrown if the app being retrieved has not yet been\n * initialized.\n *\n * @example\n * ```javascript\n * // Return the default app\n * const app = getApp();\n * ```\n *\n * @example\n * ```javascript\n * // Return a named app\n * const otherApp = getApp(\"otherApp\");\n * ```\n *\n * @param name - Optional name of the app to return. If no name is\n *   provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The app corresponding to the provided app name.\n *   If no app name is provided, the default app is returned.\n *\n * @public\n */\nexport function getApp(name: string = DEFAULT_ENTRY_NAME): FirebaseApp {\n  const app = _apps.get(name);\n  if (!app && name === DEFAULT_ENTRY_NAME && getDefaultAppConfig()) {\n    return initializeApp();\n  }\n  if (!app) {\n    throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n  }\n\n  return app;\n}\n\n/**\n * A (read-only) array of all initialized apps.\n * @public\n */\nexport function getApps(): FirebaseApp[] {\n  return Array.from(_apps.values());\n}\n\n/**\n * Renders this app unusable and frees the resources of all associated\n * services.\n *\n * @example\n * ```javascript\n * deleteApp(app)\n *   .then(function() {\n *     console.log(\"App deleted successfully\");\n *   })\n *   .catch(function(error) {\n *     console.log(\"Error deleting app:\", error);\n *   });\n * ```\n *\n * @public\n */\nexport async function deleteApp(app: FirebaseApp): Promise<void> {\n  let cleanupProviders = false;\n  const name = app.name;\n  if (_apps.has(name)) {\n    cleanupProviders = true;\n    _apps.delete(name);\n  } else if (_serverApps.has(name)) {\n    const firebaseServerApp = app as FirebaseServerAppImpl;\n    if (firebaseServerApp.decRefCount() <= 0) {\n      _serverApps.delete(name);\n      cleanupProviders = true;\n    }\n  }\n\n  if (cleanupProviders) {\n    await Promise.all(\n      (app as FirebaseAppImpl).container\n        .getProviders()\n        .map(provider => provider.delete())\n    );\n    (app as FirebaseAppImpl).isDeleted = true;\n  }\n}\n\n/**\n * Registers a library's name and version for platform logging purposes.\n * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)\n * @param version - Current version of that library.\n * @param variant - Bundle variant, e.g., node, rn, etc.\n *\n * @public\n */\nexport function registerVersion(\n  libraryKeyOrName: string,\n  version: string,\n  variant?: string\n): void {\n  // TODO: We can use this check to whitelist strings when/if we set up\n  // a good whitelist system.\n  let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? libraryKeyOrName;\n  if (variant) {\n    library += `-${variant}`;\n  }\n  const libraryMismatch = library.match(/\\s|\\//);\n  const versionMismatch = version.match(/\\s|\\//);\n  if (libraryMismatch || versionMismatch) {\n    const warning = [\n      `Unable to register library \"${library}\" with version \"${version}\":`\n    ];\n    if (libraryMismatch) {\n      warning.push(\n        `library name \"${library}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    if (libraryMismatch && versionMismatch) {\n      warning.push('and');\n    }\n    if (versionMismatch) {\n      warning.push(\n        `version name \"${version}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    logger.warn(warning.join(' '));\n    return;\n  }\n  _registerComponent(\n    new Component(\n      `${library}-version` as Name,\n      () => ({ library, version }),\n      ComponentType.VERSION\n    )\n  );\n}\n\n/**\n * Sets log handler for all Firebase SDKs.\n * @param logCallback - An optional custom log handler that executes user code whenever\n * the Firebase SDK makes a logging call.\n *\n * @public\n */\nexport function onLog(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  if (logCallback !== null && typeof logCallback !== 'function') {\n    throw ERROR_FACTORY.create(AppError.INVALID_LOG_ARGUMENT);\n  }\n  setUserLogHandler(logCallback, options);\n}\n\n/**\n * Sets log level for all Firebase SDKs.\n *\n * All of the log types above the current log level are captured (i.e. if\n * you set the log level to `info`, errors are logged, but `debug` and\n * `verbose` logs are not).\n *\n * @public\n */\nexport function setLogLevel(logLevel: LogLevelString): void {\n  setLogLevelImpl(logLevel);\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { DBSchema, openDB, IDBPDatabase } from 'idb';\nimport { AppError, ERROR_FACTORY } from './errors';\nimport { FirebaseApp } from './public-types';\nimport { HeartbeatsInIndexedDB } from './types';\nimport { logger } from './logger';\n\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\n\ninterface AppDB extends DBSchema {\n  'firebase-heartbeat-store': {\n    key: string;\n    value: HeartbeatsInIndexedDB;\n  };\n}\n\nlet dbPromise: Promise<IDBPDatabase<AppDB>> | null = null;\nfunction getDbPromise(): Promise<IDBPDatabase<AppDB>> {\n  if (!dbPromise) {\n    dbPromise = openDB<AppDB>(DB_NAME, DB_VERSION, {\n      upgrade: (db, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            try {\n              db.createObjectStore(STORE_NAME);\n            } catch (e) {\n              // Safari/iOS browsers throw occasional exceptions on\n              // db.createObjectStore() that may be a bug. Avoid blocking\n              // the rest of the app functionality.\n              console.warn(e);\n            }\n        }\n      }\n    }).catch(e => {\n      throw ERROR_FACTORY.create(AppError.IDB_OPEN, {\n        originalErrorMessage: e.message\n      });\n    });\n  }\n  return dbPromise;\n}\n\nexport async function readHeartbeatsFromIndexedDB(\n  app: FirebaseApp\n): Promise<HeartbeatsInIndexedDB | undefined> {\n  try {\n    const db = await getDbPromise();\n    const tx = db.transaction(STORE_NAME);\n    const result = await tx.objectStore(STORE_NAME).get(computeKey(app));\n    // We already have the value but tx.done can throw,\n    // so we need to await it here to catch errors\n    await tx.done;\n    return result;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(AppError.IDB_GET, {\n        originalErrorMessage: (e as Error)?.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\n\nexport async function writeHeartbeatsToIndexedDB(\n  app: FirebaseApp,\n  heartbeatObject: HeartbeatsInIndexedDB\n): Promise<void> {\n  try {\n    const db = await getDbPromise();\n    const tx = db.transaction(STORE_NAME, 'readwrite');\n    const objectStore = tx.objectStore(STORE_NAME);\n    await objectStore.put(heartbeatObject, computeKey(app));\n    await tx.done;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(AppError.IDB_WRITE, {\n        originalErrorMessage: (e as Error)?.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\n\nfunction computeKey(app: FirebaseApp): string {\n  return `${app.name}!${app.options.appId}`;\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ComponentContainer } from '@firebase/component';\nimport {\n  base64urlEncodeWithoutPadding,\n  isIndexedDBAvailable,\n  validateIndexedDBOpenable\n} from '@firebase/util';\nimport {\n  readHeartbeatsFromIndexedDB,\n  writeHeartbeatsToIndexedDB\n} from './indexeddb';\nimport { FirebaseApp } from './public-types';\nimport {\n  HeartbeatsByUserAgent,\n  HeartbeatService,\n  HeartbeatsInIndexedDB,\n  HeartbeatStorage,\n  SingleDateHeartbeat\n} from './types';\nimport { logger } from './logger';\n\nconst MAX_HEADER_BYTES = 1024;\nexport const MAX_NUM_STORED_HEARTBEATS = 30;\n\nexport class HeartbeatServiceImpl implements HeartbeatService {\n  /**\n   * The persistence layer for heartbeats\n   * Leave public for easier testing.\n   */\n  _storage: HeartbeatStorageImpl;\n\n  /**\n   * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate\n   * the header string.\n   * Stores one record per date. This will be consolidated into the standard\n   * format of one record per user agent string before being sent as a header.\n   * Populated from indexedDB when the controller is instantiated and should\n   * be kept in sync with indexedDB.\n   * Leave public for easier testing.\n   */\n  _heartbeatsCache: HeartbeatsInIndexedDB | null = null;\n\n  /**\n   * the initialization promise for populating heartbeatCache.\n   * If getHeartbeatsHeader() is called before the promise resolves\n   * (heartbeatsCache == null), it should wait for this promise\n   * Leave public for easier testing.\n   */\n  _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;\n  constructor(private readonly container: ComponentContainer) {\n    const app = this.container.getProvider('app').getImmediate();\n    this._storage = new HeartbeatStorageImpl(app);\n    this._heartbeatsCachePromise = this._storage.read().then(result => {\n      this._heartbeatsCache = result;\n      return result;\n    });\n  }\n\n  /**\n   * Called to report a heartbeat. The function will generate\n   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it\n   * to IndexedDB.\n   * Note that we only store one heartbeat per day. So if a heartbeat for today is\n   * already logged, subsequent calls to this function in the same day will be ignored.\n   */\n  async triggerHeartbeat(): Promise<void> {\n    try {\n      const platformLogger = this.container\n        .getProvider('platform-logger')\n        .getImmediate();\n\n      // This is the \"Firebase user agent\" string from the platform logger\n      // service, not the browser user agent.\n      const agent = platformLogger.getPlatformInfoString();\n      const date = getUTCDateString();\n      if (this._heartbeatsCache?.heartbeats == null) {\n        this._heartbeatsCache = await this._heartbeatsCachePromise;\n        // If we failed to construct a heartbeats cache, then return immediately.\n        if (this._heartbeatsCache?.heartbeats == null) {\n          return;\n        }\n      }\n      // Do not store a heartbeat if one is already stored for this day\n      // or if a header has already been sent today.\n      if (\n        this._heartbeatsCache.lastSentHeartbeatDate === date ||\n        this._heartbeatsCache.heartbeats.some(\n          singleDateHeartbeat => singleDateHeartbeat.date === date\n        )\n      ) {\n        return;\n      } else {\n        // There is no entry for this date. Create one.\n        this._heartbeatsCache.heartbeats.push({ date, agent });\n\n        // If the number of stored heartbeats exceeds the maximum number of stored heartbeats, remove the heartbeat with the earliest date.\n        // Since this is executed each time a heartbeat is pushed, the limit can only be exceeded by one, so only one needs to be removed.\n        if (\n          this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS\n        ) {\n          const earliestHeartbeatIdx = getEarliestHeartbeatIdx(\n            this._heartbeatsCache.heartbeats\n          );\n          this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);\n        }\n      }\n\n      return this._storage.overwrite(this._heartbeatsCache);\n    } catch (e) {\n      logger.warn(e);\n    }\n  }\n\n  /**\n   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.\n   * It also clears all heartbeats from memory as well as in IndexedDB.\n   *\n   * NOTE: Consuming product SDKs should not send the header if this method\n   * returns an empty string.\n   */\n  async getHeartbeatsHeader(): Promise<string> {\n    try {\n      if (this._heartbeatsCache === null) {\n        await this._heartbeatsCachePromise;\n      }\n      // If it's still null or the array is empty, there is no data to send.\n      if (\n        this._heartbeatsCache?.heartbeats == null ||\n        this._heartbeatsCache.heartbeats.length === 0\n      ) {\n        return '';\n      }\n      const date = getUTCDateString();\n      // Extract as many heartbeats from the cache as will fit under the size limit.\n      const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(\n        this._heartbeatsCache.heartbeats\n      );\n      const headerString = base64urlEncodeWithoutPadding(\n        JSON.stringify({ version: 2, heartbeats: heartbeatsToSend })\n      );\n      // Store last sent date to prevent another being logged/sent for the same day.\n      this._heartbeatsCache.lastSentHeartbeatDate = date;\n      if (unsentEntries.length > 0) {\n        // Store any unsent entries if they exist.\n        this._heartbeatsCache.heartbeats = unsentEntries;\n        // This seems more likely than emptying the array (below) to lead to some odd state\n        // since the cache isn't empty and this will be called again on the next request,\n        // and is probably safest if we await it.\n        await this._storage.overwrite(this._heartbeatsCache);\n      } else {\n        this._heartbeatsCache.heartbeats = [];\n        // Do not wait for this, to reduce latency.\n        void this._storage.overwrite(this._heartbeatsCache);\n      }\n      return headerString;\n    } catch (e) {\n      logger.warn(e);\n      return '';\n    }\n  }\n}\n\nfunction getUTCDateString(): string {\n  const today = new Date();\n  // Returns date format 'YYYY-MM-DD'\n  return today.toISOString().substring(0, 10);\n}\n\nexport function extractHeartbeatsForHeader(\n  heartbeatsCache: SingleDateHeartbeat[],\n  maxSize = MAX_HEADER_BYTES\n): {\n  heartbeatsToSend: HeartbeatsByUserAgent[];\n  unsentEntries: SingleDateHeartbeat[];\n} {\n  // Heartbeats grouped by user agent in the standard format to be sent in\n  // the header.\n  const heartbeatsToSend: HeartbeatsByUserAgent[] = [];\n  // Single date format heartbeats that are not sent.\n  let unsentEntries = heartbeatsCache.slice();\n  for (const singleDateHeartbeat of heartbeatsCache) {\n    // Look for an existing entry with the same user agent.\n    const heartbeatEntry = heartbeatsToSend.find(\n      hb => hb.agent === singleDateHeartbeat.agent\n    );\n    if (!heartbeatEntry) {\n      // If no entry for this user agent exists, create one.\n      heartbeatsToSend.push({\n        agent: singleDateHeartbeat.agent,\n        dates: [singleDateHeartbeat.date]\n      });\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        // If the header would exceed max size, remove the added heartbeat\n        // entry and stop adding to the header.\n        heartbeatsToSend.pop();\n        break;\n      }\n    } else {\n      heartbeatEntry.dates.push(singleDateHeartbeat.date);\n      // If the header would exceed max size, remove the added date\n      // and stop adding to the header.\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        heartbeatEntry.dates.pop();\n        break;\n      }\n    }\n    // Pop unsent entry from queue. (Skipped if adding the entry exceeded\n    // quota and the loop breaks early.)\n    unsentEntries = unsentEntries.slice(1);\n  }\n  return {\n    heartbeatsToSend,\n    unsentEntries\n  };\n}\n\nexport class HeartbeatStorageImpl implements HeartbeatStorage {\n  private _canUseIndexedDBPromise: Promise<boolean>;\n  constructor(public app: FirebaseApp) {\n    this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();\n  }\n  async runIndexedDBEnvironmentCheck(): Promise<boolean> {\n    if (!isIndexedDBAvailable()) {\n      return false;\n    } else {\n      return validateIndexedDBOpenable()\n        .then(() => true)\n        .catch(() => false);\n    }\n  }\n  /**\n   * Read all heartbeats.\n   */\n  async read(): Promise<HeartbeatsInIndexedDB> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return { heartbeats: [] };\n    } else {\n      const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);\n      if (idbHeartbeatObject?.heartbeats) {\n        return idbHeartbeatObject;\n      } else {\n        return { heartbeats: [] };\n      }\n    }\n  }\n  // overwrite the storage with the provided heartbeats\n  async overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: heartbeatsObject.heartbeats\n      });\n    }\n  }\n  // add heartbeats\n  async add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: [\n          ...existingHeartbeatsObject.heartbeats,\n          ...heartbeatsObject.heartbeats\n        ]\n      });\n    }\n  }\n}\n\n/**\n * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped\n * in a platform logging header JSON object, stringified, and converted\n * to base 64.\n */\nexport function countBytes(heartbeatsCache: HeartbeatsByUserAgent[]): number {\n  // base64 has a restricted set of characters, all of which should be 1 byte.\n  return base64urlEncodeWithoutPadding(\n    // heartbeatsCache wrapper properties\n    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })\n  ).length;\n}\n\n/**\n * Returns the index of the heartbeat with the earliest date.\n * If the heartbeats array is empty, -1 is returned.\n */\nexport function getEarliestHeartbeatIdx(\n  heartbeats: SingleDateHeartbeat[]\n): number {\n  if (heartbeats.length === 0) {\n    return -1;\n  }\n\n  let earliestHeartbeatIdx = 0;\n  let earliestHeartbeatDate = heartbeats[0].date;\n\n  for (let i = 1; i < heartbeats.length; i++) {\n    if (heartbeats[i].date < earliestHeartbeatDate) {\n      earliestHeartbeatDate = heartbeats[i].date;\n      earliestHeartbeatIdx = i;\n    }\n  }\n\n  return earliestHeartbeatIdx;\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Component, ComponentType } from '@firebase/component';\nimport { PlatformLoggerServiceImpl } from './platformLoggerService';\nimport { name, version } from '../package.json';\nimport { _registerComponent } from './internal';\nimport { registerVersion } from './api';\nimport { HeartbeatServiceImpl } from './heartbeatService';\n\nexport function registerCoreComponents(variant?: string): void {\n  _registerComponent(\n    new Component(\n      'platform-logger',\n      container => new PlatformLoggerServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n  _registerComponent(\n    new Component(\n      'heartbeat',\n      container => new HeartbeatServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n\n  // Register `app` package.\n  registerVersion(name, version, variant);\n  // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n  // Register platform SDK identifier (no version).\n  registerVersion('fire-js', '');\n}\n", "/**\n * Firebase App\n *\n * @remarks This package coordinates the communication between the different Firebase components\n * @packageDocumentation\n */\n\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { registerCoreComponents } from './registerCoreComponents';\n\nexport * from './api';\nexport * from './internal';\nexport * from './public-types';\n\nregisterCoreComponents('__RUNTIME_ENV__');\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { registerVersion } from '@firebase/app';\nimport { name, version } from '../package.json';\n\nregisterVersion(name, version, 'app');\nexport * from '@firebase/app';\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * An enum of factors that may be used for multifactor authentication.\n *\n * @public\n */\nexport const FactorId = {\n  /** Phone as second factor */\n  PHONE: 'phone',\n  TOTP: 'totp'\n} as const;\n\n/**\n * Enumeration of supported providers.\n *\n * @public\n */\nexport const ProviderId = {\n  /** Facebook provider ID */\n  FACEBOOK: 'facebook.com',\n  /** GitHub provider ID */\n  GITHUB: 'github.com',\n  /** Google provider ID */\n  GOOGLE: 'google.com',\n  /** Password provider */\n  PASSWORD: 'password',\n  /** Phone provider */\n  PHONE: 'phone',\n  /** Twitter provider ID */\n  TWITTER: 'twitter.com'\n} as const;\n\n/**\n * Enumeration of supported sign-in methods.\n *\n * @public\n */\nexport const SignInMethod = {\n  /** Email link sign in method */\n  EMAIL_LINK: 'emailLink',\n  /** Email/password sign in method */\n  EMAIL_PASSWORD: 'password',\n  /** Facebook sign in method */\n  FACEBOOK: 'facebook.com',\n  /** GitHub sign in method */\n  GITHUB: 'github.com',\n  /** Google sign in method */\n  GOOGLE: 'google.com',\n  /** Phone sign in method */\n  PHONE: 'phone',\n  /** Twitter sign in method */\n  TWITTER: 'twitter.com'\n} as const;\n\n/**\n * Enumeration of supported operation types.\n *\n * @public\n */\nexport const OperationType = {\n  /** Operation involving linking an additional provider to an already signed-in user. */\n  LINK: 'link',\n  /** Operation involving using a provider to reauthenticate an already signed-in user. */\n  REAUTHENTICATE: 'reauthenticate',\n  /** Operation involving signing in a user. */\n  SIGN_IN: 'signIn'\n} as const;\n\n/**\n * An enumeration of the possible email action types.\n *\n * @public\n */\nexport const ActionCodeOperation = {\n  /** The email link sign-in action. */\n  EMAIL_SIGNIN: 'EMAIL_SIGNIN',\n  /** The password reset action. */\n  PASSWORD_RESET: 'PASSWORD_RESET',\n  /** The email revocation action. */\n  RECOVER_EMAIL: 'RECOVER_EMAIL',\n  /** The revert second factor addition email action. */\n  REVERT_SECOND_FACTOR_ADDITION: 'REVERT_SECOND_FACTOR_ADDITION',\n  /** The revert second factor addition email action. */\n  VERIFY_AND_CHANGE_EMAIL: 'VERIFY_AND_CHANGE_EMAIL',\n  /** The email verification action. */\n  VERIFY_EMAIL: 'VERIFY_EMAIL'\n} as const;\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorMap, User } from '../model/public_types';\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nimport { IdTokenMfaResponse } from '../api/authentication/mfa';\nimport { AppName } from '../model/auth';\nimport { AuthCredential } from './credentials';\n\n/**\n * Enumeration of Firebase Auth error codes.\n *\n * @internal\n */\nexport const enum AuthErrorCode {\n  ADMIN_ONLY_OPERATION = 'admin-restricted-operation',\n  ARGUMENT_ERROR = 'argument-error',\n  APP_NOT_AUTHORIZED = 'app-not-authorized',\n  APP_NOT_INSTALLED = 'app-not-installed',\n  CAPTCHA_CHECK_FAILED = 'captcha-check-failed',\n  CODE_EXPIRED = 'code-expired',\n  CORDOVA_NOT_READY = 'cordova-not-ready',\n  CORS_UNSUPPORTED = 'cors-unsupported',\n  CREDENTIAL_ALREADY_IN_USE = 'credential-already-in-use',\n  CREDENTIAL_MISMATCH = 'custom-token-mismatch',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN = 'requires-recent-login',\n  DEPENDENT_SDK_INIT_BEFORE_AUTH = 'dependent-sdk-initialized-before-auth',\n  DYNAMIC_LINK_NOT_ACTIVATED = 'dynamic-link-not-activated',\n  EMAIL_CHANGE_NEEDS_VERIFICATION = 'email-change-needs-verification',\n  EMAIL_EXISTS = 'email-already-in-use',\n  EMULATOR_CONFIG_FAILED = 'emulator-config-failed',\n  EXPIRED_OOB_CODE = 'expired-action-code',\n  EXPIRED_POPUP_REQUEST = 'cancelled-popup-request',\n  INTERNAL_ERROR = 'internal-error',\n  INVALID_API_KEY = 'invalid-api-key',\n  INVALID_APP_CREDENTIAL = 'invalid-app-credential',\n  INVALID_APP_ID = 'invalid-app-id',\n  INVALID_AUTH = 'invalid-user-token',\n  INVALID_AUTH_EVENT = 'invalid-auth-event',\n  INVALID_CERT_HASH = 'invalid-cert-hash',\n  INVALID_CODE = 'invalid-verification-code',\n  INVALID_CONTINUE_URI = 'invalid-continue-uri',\n  INVALID_CORDOVA_CONFIGURATION = 'invalid-cordova-configuration',\n  INVALID_CUSTOM_TOKEN = 'invalid-custom-token',\n  INVALID_DYNAMIC_LINK_DOMAIN = 'invalid-dynamic-link-domain',\n  INVALID_EMAIL = 'invalid-email',\n  INVALID_EMULATOR_SCHEME = 'invalid-emulator-scheme',\n  INVALID_CREDENTIAL = 'invalid-credential',\n  INVALID_MESSAGE_PAYLOAD = 'invalid-message-payload',\n  INVALID_MFA_SESSION = 'invalid-multi-factor-session',\n  INVALID_OAUTH_CLIENT_ID = 'invalid-oauth-client-id',\n  INVALID_OAUTH_PROVIDER = 'invalid-oauth-provider',\n  INVALID_OOB_CODE = 'invalid-action-code',\n  INVALID_ORIGIN = 'unauthorized-domain',\n  INVALID_PASSWORD = 'wrong-password',\n  INVALID_PERSISTENCE = 'invalid-persistence-type',\n  INVALID_PHONE_NUMBER = 'invalid-phone-number',\n  INVALID_PROVIDER_ID = 'invalid-provider-id',\n  INVALID_RECIPIENT_EMAIL = 'invalid-recipient-email',\n  INVALID_SENDER = 'invalid-sender',\n  INVALID_SESSION_INFO = 'invalid-verification-id',\n  INVALID_TENANT_ID = 'invalid-tenant-id',\n  LOGIN_BLOCKED = 'login-blocked',\n  MFA_INFO_NOT_FOUND = 'multi-factor-info-not-found',\n  MFA_REQUIRED = 'multi-factor-auth-required',\n  MISSING_ANDROID_PACKAGE_NAME = 'missing-android-pkg-name',\n  MISSING_APP_CREDENTIAL = 'missing-app-credential',\n  MISSING_AUTH_DOMAIN = 'auth-domain-config-required',\n  MISSING_CODE = 'missing-verification-code',\n  MISSING_CONTINUE_URI = 'missing-continue-uri',\n  MISSING_IFRAME_START = 'missing-iframe-start',\n  MISSING_IOS_BUNDLE_ID = 'missing-ios-bundle-id',\n  MISSING_OR_INVALID_NONCE = 'missing-or-invalid-nonce',\n  MISSING_MFA_INFO = 'missing-multi-factor-info',\n  MISSING_MFA_SESSION = 'missing-multi-factor-session',\n  MISSING_PHONE_NUMBER = 'missing-phone-number',\n  MISSING_PASSWORD = 'missing-password',\n  MISSING_SESSION_INFO = 'missing-verification-id',\n  MODULE_DESTROYED = 'app-deleted',\n  NEED_CONFIRMATION = 'account-exists-with-different-credential',\n  NETWORK_REQUEST_FAILED = 'network-request-failed',\n  NULL_USER = 'null-user',\n  NO_AUTH_EVENT = 'no-auth-event',\n  NO_SUCH_PROVIDER = 'no-such-provider',\n  OPERATION_NOT_ALLOWED = 'operation-not-allowed',\n  OPERATION_NOT_SUPPORTED = 'operation-not-supported-in-this-environment',\n  POPUP_BLOCKED = 'popup-blocked',\n  POPUP_CLOSED_BY_USER = 'popup-closed-by-user',\n  PROVIDER_ALREADY_LINKED = 'provider-already-linked',\n  QUOTA_EXCEEDED = 'quota-exceeded',\n  REDIRECT_CANCELLED_BY_USER = 'redirect-cancelled-by-user',\n  REDIRECT_OPERATION_PENDING = 'redirect-operation-pending',\n  REJECTED_CREDENTIAL = 'rejected-credential',\n  SECOND_FACTOR_ALREADY_ENROLLED = 'second-factor-already-in-use',\n  SECOND_FACTOR_LIMIT_EXCEEDED = 'maximum-second-factor-count-exceeded',\n  TENANT_ID_MISMATCH = 'tenant-id-mismatch',\n  TIMEOUT = 'timeout',\n  TOKEN_EXPIRED = 'user-token-expired',\n  TOO_MANY_ATTEMPTS_TRY_LATER = 'too-many-requests',\n  UNAUTHORIZED_DOMAIN = 'unauthorized-continue-uri',\n  UNSUPPORTED_FIRST_FACTOR = 'unsupported-first-factor',\n  UNSUPPORTED_PERSISTENCE = 'unsupported-persistence-type',\n  UNSUPPORTED_TENANT_OPERATION = 'unsupported-tenant-operation',\n  UNVERIFIED_EMAIL = 'unverified-email',\n  USER_CANCELLED = 'user-cancelled',\n  USER_DELETED = 'user-not-found',\n  USER_DISABLED = 'user-disabled',\n  USER_MISMATCH = 'user-mismatch',\n  USER_SIGNED_OUT = 'user-signed-out',\n  WEAK_PASSWORD = 'weak-password',\n  WEB_STORAGE_UNSUPPORTED = 'web-storage-unsupported',\n  ALREADY_INITIALIZED = 'already-initialized',\n  RECAPTCHA_NOT_ENABLED = 'recaptcha-not-enabled',\n  MISSING_RECAPTCHA_TOKEN = 'missing-recaptcha-token',\n  INVALID_RECAPTCHA_TOKEN = 'invalid-recaptcha-token',\n  INVALID_RECAPTCHA_ACTION = 'invalid-recaptcha-action',\n  MISSING_CLIENT_TYPE = 'missing-client-type',\n  MISSING_RECAPTCHA_VERSION = 'missing-recaptcha-version',\n  INVALID_RECAPTCHA_VERSION = 'invalid-recaptcha-version',\n  INVALID_REQ_TYPE = 'invalid-req-type',\n  UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION = 'unsupported-password-policy-schema-version',\n  PASSWORD_DOES_NOT_MEET_REQUIREMENTS = 'password-does-not-meet-requirements',\n  INVALID_HOSTING_LINK_DOMAIN = 'invalid-hosting-link-domain'\n}\n\nfunction _debugErrorMap(): ErrorMap<AuthErrorCode> {\n  return {\n    [AuthErrorCode.ADMIN_ONLY_OPERATION]:\n      'This operation is restricted to administrators only.',\n    [AuthErrorCode.ARGUMENT_ERROR]: '',\n    [AuthErrorCode.APP_NOT_AUTHORIZED]:\n      \"This app, identified by the domain where it's hosted, is not \" +\n      'authorized to use Firebase Authentication with the provided API key. ' +\n      'Review your key configuration in the Google API console.',\n    [AuthErrorCode.APP_NOT_INSTALLED]:\n      'The requested mobile application corresponding to the identifier (' +\n      'Android package name or iOS bundle ID) provided is not installed on ' +\n      'this device.',\n    [AuthErrorCode.CAPTCHA_CHECK_FAILED]:\n      'The reCAPTCHA response token provided is either invalid, expired, ' +\n      'already used or the domain associated with it does not match the list ' +\n      'of whitelisted domains.',\n    [AuthErrorCode.CODE_EXPIRED]:\n      'The SMS code has expired. Please re-send the verification code to try ' +\n      'again.',\n    [AuthErrorCode.CORDOVA_NOT_READY]: 'Cordova framework is not ready.',\n    [AuthErrorCode.CORS_UNSUPPORTED]: 'This browser is not supported.',\n    [AuthErrorCode.CREDENTIAL_ALREADY_IN_USE]:\n      'This credential is already associated with a different user account.',\n    [AuthErrorCode.CREDENTIAL_MISMATCH]:\n      'The custom token corresponds to a different audience.',\n    [AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN]:\n      'This operation is sensitive and requires recent authentication. Log in ' +\n      'again before retrying this request.',\n    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]:\n      'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +\n      'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +\n      'starting any other Firebase SDK.',\n    [AuthErrorCode.DYNAMIC_LINK_NOT_ACTIVATED]:\n      'Please activate Dynamic Links in the Firebase Console and agree to the terms and ' +\n      'conditions.',\n    [AuthErrorCode.EMAIL_CHANGE_NEEDS_VERIFICATION]:\n      'Multi-factor users must always have a verified email.',\n    [AuthErrorCode.EMAIL_EXISTS]:\n      'The email address is already in use by another account.',\n    [AuthErrorCode.EMULATOR_CONFIG_FAILED]:\n      'Auth instance has already been used to make a network call. Auth can ' +\n      'no longer be configured to use the emulator. Try calling ' +\n      '\"connectAuthEmulator()\" sooner.',\n    [AuthErrorCode.EXPIRED_OOB_CODE]: 'The action code has expired.',\n    [AuthErrorCode.EXPIRED_POPUP_REQUEST]:\n      'This operation has been cancelled due to another conflicting popup being opened.',\n    [AuthErrorCode.INTERNAL_ERROR]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.INVALID_APP_CREDENTIAL]:\n      'The phone verification request contains an invalid application verifier.' +\n      ' The reCAPTCHA token response is either invalid or expired.',\n    [AuthErrorCode.INVALID_APP_ID]:\n      'The mobile app identifier is not registered for the current project.',\n    [AuthErrorCode.INVALID_AUTH]:\n      \"This user's credential isn't valid for this project. This can happen \" +\n      \"if the user's token has been tampered with, or if the user isn't for \" +\n      'the project associated with this API key.',\n    [AuthErrorCode.INVALID_AUTH_EVENT]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.INVALID_CODE]:\n      'The SMS verification code used to create the phone auth credential is ' +\n      'invalid. Please resend the verification code sms and be sure to use the ' +\n      'verification code provided by the user.',\n    [AuthErrorCode.INVALID_CONTINUE_URI]:\n      'The continue URL provided in the request is invalid.',\n    [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]:\n      'The following Cordova plugins must be installed to enable OAuth sign-in: ' +\n      'cordova-plugin-buildinfo, cordova-universal-links-plugin, ' +\n      'cordova-plugin-browsertab, cordova-plugin-inappbrowser and ' +\n      'cordova-plugin-customurlscheme.',\n    [AuthErrorCode.INVALID_CUSTOM_TOKEN]:\n      'The custom token format is incorrect. Please check the documentation.',\n    [AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN]:\n      'The provided dynamic link domain is not configured or authorized for the current project.',\n    [AuthErrorCode.INVALID_EMAIL]: 'The email address is badly formatted.',\n    [AuthErrorCode.INVALID_EMULATOR_SCHEME]:\n      'Emulator URL must start with a valid scheme (http:// or https://).',\n    [AuthErrorCode.INVALID_API_KEY]:\n      'Your API key is invalid, please check you have copied it correctly.',\n    [AuthErrorCode.INVALID_CERT_HASH]:\n      'The SHA-1 certificate hash provided is invalid.',\n    [AuthErrorCode.INVALID_CREDENTIAL]:\n      'The supplied auth credential is incorrect, malformed or has expired.',\n    [AuthErrorCode.INVALID_MESSAGE_PAYLOAD]:\n      'The email template corresponding to this action contains invalid characters in its message. ' +\n      'Please fix by going to the Auth email templates section in the Firebase Console.',\n    [AuthErrorCode.INVALID_MFA_SESSION]:\n      'The request does not contain a valid proof of first factor successful sign-in.',\n    [AuthErrorCode.INVALID_OAUTH_PROVIDER]:\n      'EmailAuthProvider is not supported for this operation. This operation ' +\n      'only supports OAuth providers.',\n    [AuthErrorCode.INVALID_OAUTH_CLIENT_ID]:\n      'The OAuth client ID provided is either invalid or does not match the ' +\n      'specified API key.',\n    [AuthErrorCode.INVALID_ORIGIN]:\n      'This domain is not authorized for OAuth operations for your Firebase ' +\n      'project. Edit the list of authorized domains from the Firebase console.',\n    [AuthErrorCode.INVALID_OOB_CODE]:\n      'The action code is invalid. This can happen if the code is malformed, ' +\n      'expired, or has already been used.',\n    [AuthErrorCode.INVALID_PASSWORD]:\n      'The password is invalid or the user does not have a password.',\n    [AuthErrorCode.INVALID_PERSISTENCE]:\n      'The specified persistence type is invalid. It can only be local, session or none.',\n    [AuthErrorCode.INVALID_PHONE_NUMBER]:\n      'The format of the phone number provided is incorrect. Please enter the ' +\n      'phone number in a format that can be parsed into E.164 format. E.164 ' +\n      'phone numbers are written in the format [+][country code][subscriber ' +\n      'number including area code].',\n    [AuthErrorCode.INVALID_PROVIDER_ID]:\n      'The specified provider ID is invalid.',\n    [AuthErrorCode.INVALID_RECIPIENT_EMAIL]:\n      'The email corresponding to this action failed to send as the provided ' +\n      'recipient email address is invalid.',\n    [AuthErrorCode.INVALID_SENDER]:\n      'The email template corresponding to this action contains an invalid sender email or name. ' +\n      'Please fix by going to the Auth email templates section in the Firebase Console.',\n    [AuthErrorCode.INVALID_SESSION_INFO]:\n      'The verification ID used to create the phone auth credential is invalid.',\n    [AuthErrorCode.INVALID_TENANT_ID]:\n      \"The Auth instance's tenant ID is invalid.\",\n    [AuthErrorCode.LOGIN_BLOCKED]:\n      'Login blocked by user-provided method: {$originalMessage}',\n    [AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME]:\n      'An Android Package Name must be provided if the Android App is required to be installed.',\n    [AuthErrorCode.MISSING_AUTH_DOMAIN]:\n      'Be sure to include authDomain when calling firebase.initializeApp(), ' +\n      'by following the instructions in the Firebase console.',\n    [AuthErrorCode.MISSING_APP_CREDENTIAL]:\n      'The phone verification request is missing an application verifier ' +\n      'assertion. A reCAPTCHA response token needs to be provided.',\n    [AuthErrorCode.MISSING_CODE]:\n      'The phone auth credential was created with an empty SMS verification code.',\n    [AuthErrorCode.MISSING_CONTINUE_URI]:\n      'A continue URL must be provided in the request.',\n    [AuthErrorCode.MISSING_IFRAME_START]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.MISSING_IOS_BUNDLE_ID]:\n      'An iOS Bundle ID must be provided if an App Store ID is provided.',\n    [AuthErrorCode.MISSING_OR_INVALID_NONCE]:\n      'The request does not contain a valid nonce. This can occur if the ' +\n      'SHA-256 hash of the provided raw nonce does not match the hashed nonce ' +\n      'in the ID token payload.',\n    [AuthErrorCode.MISSING_PASSWORD]: 'A non-empty password must be provided',\n    [AuthErrorCode.MISSING_MFA_INFO]:\n      'No second factor identifier is provided.',\n    [AuthErrorCode.MISSING_MFA_SESSION]:\n      'The request is missing proof of first factor successful sign-in.',\n    [AuthErrorCode.MISSING_PHONE_NUMBER]:\n      'To send verification codes, provide a phone number for the recipient.',\n    [AuthErrorCode.MISSING_SESSION_INFO]:\n      'The phone auth credential was created with an empty verification ID.',\n    [AuthErrorCode.MODULE_DESTROYED]:\n      'This instance of FirebaseApp has been deleted.',\n    [AuthErrorCode.MFA_INFO_NOT_FOUND]:\n      'The user does not have a second factor matching the identifier provided.',\n    [AuthErrorCode.MFA_REQUIRED]:\n      'Proof of ownership of a second factor is required to complete sign-in.',\n    [AuthErrorCode.NEED_CONFIRMATION]:\n      'An account already exists with the same email address but different ' +\n      'sign-in credentials. Sign in using a provider associated with this ' +\n      'email address.',\n    [AuthErrorCode.NETWORK_REQUEST_FAILED]:\n      'A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.',\n    [AuthErrorCode.NO_AUTH_EVENT]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.NO_SUCH_PROVIDER]:\n      'User was not linked to an account with the given provider.',\n    [AuthErrorCode.NULL_USER]:\n      'A null user object was provided as the argument for an operation which ' +\n      'requires a non-null user object.',\n    [AuthErrorCode.OPERATION_NOT_ALLOWED]:\n      'The given sign-in provider is disabled for this Firebase project. ' +\n      'Enable it in the Firebase console, under the sign-in method tab of the ' +\n      'Auth section.',\n    [AuthErrorCode.OPERATION_NOT_SUPPORTED]:\n      'This operation is not supported in the environment this application is ' +\n      'running on. \"location.protocol\" must be http, https or chrome-extension' +\n      ' and web storage must be enabled.',\n    [AuthErrorCode.POPUP_BLOCKED]:\n      'Unable to establish a connection with the popup. It may have been blocked by the browser.',\n    [AuthErrorCode.POPUP_CLOSED_BY_USER]:\n      'The popup has been closed by the user before finalizing the operation.',\n    [AuthErrorCode.PROVIDER_ALREADY_LINKED]:\n      'User can only be linked to one identity for the given provider.',\n    [AuthErrorCode.QUOTA_EXCEEDED]:\n      \"The project's quota for this operation has been exceeded.\",\n    [AuthErrorCode.REDIRECT_CANCELLED_BY_USER]:\n      'The redirect operation has been cancelled by the user before finalizing.',\n    [AuthErrorCode.REDIRECT_OPERATION_PENDING]:\n      'A redirect sign-in operation is already pending.',\n    [AuthErrorCode.REJECTED_CREDENTIAL]:\n      'The request contains malformed or mismatching credentials.',\n    [AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED]:\n      'The second factor is already enrolled on this account.',\n    [AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED]:\n      'The maximum allowed number of second factors on a user has been exceeded.',\n    [AuthErrorCode.TENANT_ID_MISMATCH]:\n      \"The provided tenant ID does not match the Auth instance's tenant ID\",\n    [AuthErrorCode.TIMEOUT]: 'The operation has timed out.',\n    [AuthErrorCode.TOKEN_EXPIRED]:\n      \"The user's credential is no longer valid. The user must sign in again.\",\n    [AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER]:\n      'We have blocked all requests from this device due to unusual activity. ' +\n      'Try again later.',\n    [AuthErrorCode.UNAUTHORIZED_DOMAIN]:\n      'The domain of the continue URL is not whitelisted.  Please whitelist ' +\n      'the domain in the Firebase console.',\n    [AuthErrorCode.UNSUPPORTED_FIRST_FACTOR]:\n      'Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.',\n    [AuthErrorCode.UNSUPPORTED_PERSISTENCE]:\n      'The current environment does not support the specified persistence type.',\n    [AuthErrorCode.UNSUPPORTED_TENANT_OPERATION]:\n      'This operation is not supported in a multi-tenant context.',\n    [AuthErrorCode.UNVERIFIED_EMAIL]:\n      'The operation requires a verified email.',\n    [AuthErrorCode.USER_CANCELLED]:\n      'The user did not grant your application the permissions it requested.',\n    [AuthErrorCode.USER_DELETED]:\n      'There is no user record corresponding to this identifier. The user may ' +\n      'have been deleted.',\n    [AuthErrorCode.USER_DISABLED]:\n      'The user account has been disabled by an administrator.',\n    [AuthErrorCode.USER_MISMATCH]:\n      'The supplied credentials do not correspond to the previously signed in user.',\n    [AuthErrorCode.USER_SIGNED_OUT]: '',\n    [AuthErrorCode.WEAK_PASSWORD]:\n      'The password must be 6 characters long or more.',\n    [AuthErrorCode.WEB_STORAGE_UNSUPPORTED]:\n      'This browser is not supported or 3rd party cookies and data may be disabled.',\n    [AuthErrorCode.ALREADY_INITIALIZED]:\n      'initializeAuth() has already been called with ' +\n      'different options. To avoid this error, call initializeAuth() with the ' +\n      'same options as when it was originally called, or call getAuth() to return the' +\n      ' already initialized instance.',\n    [AuthErrorCode.MISSING_RECAPTCHA_TOKEN]:\n      'The reCAPTCHA token is missing when sending request to the backend.',\n    [AuthErrorCode.INVALID_RECAPTCHA_TOKEN]:\n      'The reCAPTCHA token is invalid when sending request to the backend.',\n    [AuthErrorCode.INVALID_RECAPTCHA_ACTION]:\n      'The reCAPTCHA action is invalid when sending request to the backend.',\n    [AuthErrorCode.RECAPTCHA_NOT_ENABLED]:\n      'reCAPTCHA Enterprise integration is not enabled for this project.',\n    [AuthErrorCode.MISSING_CLIENT_TYPE]:\n      'The reCAPTCHA client type is missing when sending request to the backend.',\n    [AuthErrorCode.MISSING_RECAPTCHA_VERSION]:\n      'The reCAPTCHA version is missing when sending request to the backend.',\n    [AuthErrorCode.INVALID_REQ_TYPE]: 'Invalid request parameters.',\n    [AuthErrorCode.INVALID_RECAPTCHA_VERSION]:\n      'The reCAPTCHA version is invalid when sending request to the backend.',\n    [AuthErrorCode.UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION]:\n      'The password policy received from the backend uses a schema version that is not supported by this version of the Firebase SDK.',\n    [AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS]:\n      'The password does not meet the requirements.',\n    [AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN]:\n      'The provided Hosting link domain is not configured in Firebase Hosting or is not owned by ' +\n      'the current project. This cannot be a default Hosting domain (`web.app` or `firebaseapp.com`).'\n  };\n}\n\nexport interface ErrorMapRetriever extends AuthErrorMap {\n  (): ErrorMap<AuthErrorCode>;\n}\n\nfunction _prodErrorMap(): ErrorMap<AuthErrorCode> {\n  // We will include this one message in the prod error map since by the very\n  // nature of this error, developers will never be able to see the message\n  // using the debugErrorMap (which is installed during auth initialization).\n  return {\n    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]:\n      'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +\n      'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +\n      'starting any other Firebase SDK.'\n  } as ErrorMap<AuthErrorCode>;\n}\n\n/**\n * A verbose error map with detailed descriptions for most error codes.\n *\n * See discussion at {@link AuthErrorMap}\n *\n * @public\n */\nexport const debugErrorMap: AuthErrorMap = _debugErrorMap;\n\n/**\n * A minimal error map with all verbose error messages stripped.\n *\n * See discussion at {@link AuthErrorMap}\n *\n * @public\n */\nexport const prodErrorMap: AuthErrorMap = _prodErrorMap;\n\nexport interface NamedErrorParams {\n  appName: AppName;\n  credential?: AuthCredential;\n  email?: string;\n  phoneNumber?: string;\n  tenantId?: string;\n  user?: User;\n  _serverResponse?: object;\n}\n\n/**\n * @internal\n */\ntype GenericAuthErrorParams = {\n  [key in Exclude<\n    AuthErrorCode,\n    | AuthErrorCode.ARGUMENT_ERROR\n    | AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH\n    | AuthErrorCode.INTERNAL_ERROR\n    | AuthErrorCode.MFA_REQUIRED\n    | AuthErrorCode.NO_AUTH_EVENT\n    | AuthErrorCode.OPERATION_NOT_SUPPORTED\n  >]: {\n    appName?: AppName;\n    email?: string;\n    phoneNumber?: string;\n    message?: string;\n  };\n};\n\n/**\n * @internal\n */\nexport interface AuthErrorParams extends GenericAuthErrorParams {\n  [AuthErrorCode.ARGUMENT_ERROR]: { appName?: AppName };\n  [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]: { appName?: AppName };\n  [AuthErrorCode.INTERNAL_ERROR]: { appName?: AppName };\n  [AuthErrorCode.LOGIN_BLOCKED]: {\n    appName?: AppName;\n    originalMessage?: string;\n  };\n  [AuthErrorCode.OPERATION_NOT_SUPPORTED]: { appName?: AppName };\n  [AuthErrorCode.NO_AUTH_EVENT]: { appName?: AppName };\n  [AuthErrorCode.MFA_REQUIRED]: {\n    appName: AppName;\n    _serverResponse: IdTokenMfaResponse;\n  };\n  [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]: {\n    appName: AppName;\n    missingPlugin?: string;\n  };\n}\n\nexport const _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory<\n  AuthErrorCode,\n  AuthErrorParams\n>('auth', 'Firebase', _prodErrorMap());\n\n/**\n * A map of potential `Auth` error codes, for easier comparison with errors\n * thrown by the SDK.\n *\n * @remarks\n * Note that you can't tree-shake individual keys\n * in the map, so by using the map you might substantially increase your\n * bundle size.\n *\n * @public\n */\nexport const AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY = {\n  ADMIN_ONLY_OPERATION: 'auth/admin-restricted-operation',\n  ARGUMENT_ERROR: 'auth/argument-error',\n  APP_NOT_AUTHORIZED: 'auth/app-not-authorized',\n  APP_NOT_INSTALLED: 'auth/app-not-installed',\n  CAPTCHA_CHECK_FAILED: 'auth/captcha-check-failed',\n  CODE_EXPIRED: 'auth/code-expired',\n  CORDOVA_NOT_READY: 'auth/cordova-not-ready',\n  CORS_UNSUPPORTED: 'auth/cors-unsupported',\n  CREDENTIAL_ALREADY_IN_USE: 'auth/credential-already-in-use',\n  CREDENTIAL_MISMATCH: 'auth/custom-token-mismatch',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN: 'auth/requires-recent-login',\n  DEPENDENT_SDK_INIT_BEFORE_AUTH: 'auth/dependent-sdk-initialized-before-auth',\n  DYNAMIC_LINK_NOT_ACTIVATED: 'auth/dynamic-link-not-activated',\n  EMAIL_CHANGE_NEEDS_VERIFICATION: 'auth/email-change-needs-verification',\n  EMAIL_EXISTS: 'auth/email-already-in-use',\n  EMULATOR_CONFIG_FAILED: 'auth/emulator-config-failed',\n  EXPIRED_OOB_CODE: 'auth/expired-action-code',\n  EXPIRED_POPUP_REQUEST: 'auth/cancelled-popup-request',\n  INTERNAL_ERROR: 'auth/internal-error',\n  INVALID_API_KEY: 'auth/invalid-api-key',\n  INVALID_APP_CREDENTIAL: 'auth/invalid-app-credential',\n  INVALID_APP_ID: 'auth/invalid-app-id',\n  INVALID_AUTH: 'auth/invalid-user-token',\n  INVALID_AUTH_EVENT: 'auth/invalid-auth-event',\n  INVALID_CERT_HASH: 'auth/invalid-cert-hash',\n  INVALID_CODE: 'auth/invalid-verification-code',\n  INVALID_CONTINUE_URI: 'auth/invalid-continue-uri',\n  INVALID_CORDOVA_CONFIGURATION: 'auth/invalid-cordova-configuration',\n  INVALID_CUSTOM_TOKEN: 'auth/invalid-custom-token',\n  INVALID_DYNAMIC_LINK_DOMAIN: 'auth/invalid-dynamic-link-domain',\n  INVALID_EMAIL: 'auth/invalid-email',\n  INVALID_EMULATOR_SCHEME: 'auth/invalid-emulator-scheme',\n  INVALID_IDP_RESPONSE: 'auth/invalid-credential',\n  INVALID_LOGIN_CREDENTIALS: 'auth/invalid-credential',\n  INVALID_MESSAGE_PAYLOAD: 'auth/invalid-message-payload',\n  INVALID_MFA_SESSION: 'auth/invalid-multi-factor-session',\n  INVALID_OAUTH_CLIENT_ID: 'auth/invalid-oauth-client-id',\n  INVALID_OAUTH_PROVIDER: 'auth/invalid-oauth-provider',\n  INVALID_OOB_CODE: 'auth/invalid-action-code',\n  INVALID_ORIGIN: 'auth/unauthorized-domain',\n  INVALID_PASSWORD: 'auth/wrong-password',\n  INVALID_PERSISTENCE: 'auth/invalid-persistence-type',\n  INVALID_PHONE_NUMBER: 'auth/invalid-phone-number',\n  INVALID_PROVIDER_ID: 'auth/invalid-provider-id',\n  INVALID_RECIPIENT_EMAIL: 'auth/invalid-recipient-email',\n  INVALID_SENDER: 'auth/invalid-sender',\n  INVALID_SESSION_INFO: 'auth/invalid-verification-id',\n  INVALID_TENANT_ID: 'auth/invalid-tenant-id',\n  MFA_INFO_NOT_FOUND: 'auth/multi-factor-info-not-found',\n  MFA_REQUIRED: 'auth/multi-factor-auth-required',\n  MISSING_ANDROID_PACKAGE_NAME: 'auth/missing-android-pkg-name',\n  MISSING_APP_CREDENTIAL: 'auth/missing-app-credential',\n  MISSING_AUTH_DOMAIN: 'auth/auth-domain-config-required',\n  MISSING_CODE: 'auth/missing-verification-code',\n  MISSING_CONTINUE_URI: 'auth/missing-continue-uri',\n  MISSING_IFRAME_START: 'auth/missing-iframe-start',\n  MISSING_IOS_BUNDLE_ID: 'auth/missing-ios-bundle-id',\n  MISSING_OR_INVALID_NONCE: 'auth/missing-or-invalid-nonce',\n  MISSING_MFA_INFO: 'auth/missing-multi-factor-info',\n  MISSING_MFA_SESSION: 'auth/missing-multi-factor-session',\n  MISSING_PHONE_NUMBER: 'auth/missing-phone-number',\n  MISSING_PASSWORD: 'auth/missing-password',\n  MISSING_SESSION_INFO: 'auth/missing-verification-id',\n  MODULE_DESTROYED: 'auth/app-deleted',\n  NEED_CONFIRMATION: 'auth/account-exists-with-different-credential',\n  NETWORK_REQUEST_FAILED: 'auth/network-request-failed',\n  NULL_USER: 'auth/null-user',\n  NO_AUTH_EVENT: 'auth/no-auth-event',\n  NO_SUCH_PROVIDER: 'auth/no-such-provider',\n  OPERATION_NOT_ALLOWED: 'auth/operation-not-allowed',\n  OPERATION_NOT_SUPPORTED: 'auth/operation-not-supported-in-this-environment',\n  POPUP_BLOCKED: 'auth/popup-blocked',\n  POPUP_CLOSED_BY_USER: 'auth/popup-closed-by-user',\n  PROVIDER_ALREADY_LINKED: 'auth/provider-already-linked',\n  QUOTA_EXCEEDED: 'auth/quota-exceeded',\n  REDIRECT_CANCELLED_BY_USER: 'auth/redirect-cancelled-by-user',\n  REDIRECT_OPERATION_PENDING: 'auth/redirect-operation-pending',\n  REJECTED_CREDENTIAL: 'auth/rejected-credential',\n  SECOND_FACTOR_ALREADY_ENROLLED: 'auth/second-factor-already-in-use',\n  SECOND_FACTOR_LIMIT_EXCEEDED: 'auth/maximum-second-factor-count-exceeded',\n  TENANT_ID_MISMATCH: 'auth/tenant-id-mismatch',\n  TIMEOUT: 'auth/timeout',\n  TOKEN_EXPIRED: 'auth/user-token-expired',\n  TOO_MANY_ATTEMPTS_TRY_LATER: 'auth/too-many-requests',\n  UNAUTHORIZED_DOMAIN: 'auth/unauthorized-continue-uri',\n  UNSUPPORTED_FIRST_FACTOR: 'auth/unsupported-first-factor',\n  UNSUPPORTED_PERSISTENCE: 'auth/unsupported-persistence-type',\n  UNSUPPORTED_TENANT_OPERATION: 'auth/unsupported-tenant-operation',\n  UNVERIFIED_EMAIL: 'auth/unverified-email',\n  USER_CANCELLED: 'auth/user-cancelled',\n  USER_DELETED: 'auth/user-not-found',\n  USER_DISABLED: 'auth/user-disabled',\n  USER_MISMATCH: 'auth/user-mismatch',\n  USER_SIGNED_OUT: 'auth/user-signed-out',\n  WEAK_PASSWORD: 'auth/weak-password',\n  WEB_STORAGE_UNSUPPORTED: 'auth/web-storage-unsupported',\n  ALREADY_INITIALIZED: 'auth/already-initialized',\n  RECAPTCHA_NOT_ENABLED: 'auth/recaptcha-not-enabled',\n  MISSING_RECAPTCHA_TOKEN: 'auth/missing-recaptcha-token',\n  INVALID_RECAPTCHA_TOKEN: 'auth/invalid-recaptcha-token',\n  INVALID_RECAPTCHA_ACTION: 'auth/invalid-recaptcha-action',\n  MISSING_CLIENT_TYPE: 'auth/missing-client-type',\n  MISSING_RECAPTCHA_VERSION: 'auth/missing-recaptcha-version',\n  INVALID_RECAPTCHA_VERSION: 'auth/invalid-recaptcha-version',\n  INVALID_REQ_TYPE: 'auth/invalid-req-type',\n  INVALID_HOSTING_LINK_DOMAIN: 'auth/invalid-hosting-link-domain'\n} as const;\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger, LogLevel } from '@firebase/logger';\nimport { SDK_VERSION } from '@firebase/app';\n\nexport { LogLevel };\n\nconst logClient = new Logger('@firebase/auth');\n\n// Helper methods are needed because variables can't be exported as read/write\nexport function _getLogLevel(): LogLevel {\n  return logClient.logLevel;\n}\n\nexport function _setLogLevel(newLevel: LogLevel): void {\n  logClient.logLevel = newLevel;\n}\n\nexport function _logDebug(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.DEBUG) {\n    logClient.debug(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n\nexport function _logWarn(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.WARN) {\n    logClient.warn(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n\nexport function _logError(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.ERROR) {\n    logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth } from '../../model/public_types';\nimport { ErrorFactory, FirebaseError } from '@firebase/util';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  _DEFAULT_AUTH_ERROR_FACTORY,\n  AuthErrorCode,\n  AuthErrorParams,\n  prodErrorMap,\n  ErrorMapRetriever\n} from '../errors';\nimport { _logError } from './log';\n\ntype AuthErrorListParams<K> = K extends keyof AuthErrorParams\n  ? [AuthErrorParams[K]]\n  : [];\ntype LessAppName<K extends AuthErrorCode> = Omit<AuthErrorParams[K], 'appName'>;\n\n/**\n * Unconditionally fails, throwing a developer facing INTERNAL_ERROR\n *\n * @example\n * ```javascript\n * fail(auth, AuthErrorCode.MFA_REQUIRED);  // Error: the MFA_REQUIRED error needs more params than appName\n * fail(auth, AuthErrorCode.MFA_REQUIRED, {serverResponse});  // Compiles\n * fail(AuthErrorCode.INTERNAL_ERROR);  // Compiles; internal error does not need appName\n * fail(AuthErrorCode.USER_DELETED);  // Error: USER_DELETED requires app name\n * fail(auth, AuthErrorCode.USER_DELETED);  // Compiles; USER_DELETED _only_ needs app name\n * ```\n *\n * @param appName App name for tagging the error\n * @throws FirebaseError\n */\nexport function _fail<K extends AuthErrorCode>(\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): never;\nexport function _fail<K extends AuthErrorCode>(\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): never;\nexport function _fail<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): never {\n  throw createErrorInternal(authOrCode, ...rest);\n}\n\nexport function _createError<K extends AuthErrorCode>(\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): FirebaseError;\nexport function _createError<K extends AuthErrorCode>(\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): FirebaseError;\nexport function _createError<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): FirebaseError {\n  return createErrorInternal(authOrCode, ...rest);\n}\n\nexport function _errorWithCustomMessage(\n  auth: Auth,\n  code: AuthErrorCode,\n  message: string\n): FirebaseError {\n  const errorMap = {\n    ...(prodErrorMap as ErrorMapRetriever)(),\n    [code]: message\n  };\n  const factory = new ErrorFactory<AuthErrorCode, AuthErrorParams>(\n    'auth',\n    'Firebase',\n    errorMap\n  );\n  return factory.create(code, {\n    appName: auth.name\n  });\n}\n\nexport function _serverAppCurrentUserOperationNotSupportedError(\n  auth: Auth\n): FirebaseError {\n  return _errorWithCustomMessage(\n    auth,\n    AuthErrorCode.OPERATION_NOT_SUPPORTED,\n    'Operations that alter the current user are not supported in conjunction with FirebaseServerApp'\n  );\n}\n\nexport function _assertInstanceOf(\n  auth: Auth,\n  object: object,\n  instance: unknown\n): void {\n  const constructorInstance = instance as { new (...args: unknown[]): unknown };\n  if (!(object instanceof constructorInstance)) {\n    if (constructorInstance.name !== object.constructor.name) {\n      _fail(auth, AuthErrorCode.ARGUMENT_ERROR);\n    }\n\n    throw _errorWithCustomMessage(\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR,\n      `Type of ${object.constructor.name} does not match expected instance.` +\n        `Did you pass a reference from a different Auth SDK?`\n    );\n  }\n}\n\nfunction createErrorInternal<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): FirebaseError {\n  if (typeof authOrCode !== 'string') {\n    const code = rest[0] as K;\n    const fullParams = [...rest.slice(1)] as AuthErrorListParams<K>;\n    if (fullParams[0]) {\n      fullParams[0].appName = authOrCode.name;\n    }\n\n    return (authOrCode as AuthInternal)._errorFactory.create(\n      code,\n      ...fullParams\n    );\n  }\n\n  return _DEFAULT_AUTH_ERROR_FACTORY.create(\n    authOrCode,\n    ...(rest as AuthErrorListParams<K>)\n  );\n}\n\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): asserts assertion;\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): asserts assertion;\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): asserts assertion {\n  if (!assertion) {\n    throw createErrorInternal(authOrCode, ...rest);\n  }\n}\n\n// We really do want to accept literally any function type here\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype TypeExpectation = Function | string | MapType;\n\ninterface MapType extends Record<string, TypeExpectation | Optional> {}\n\nclass Optional {\n  constructor(readonly type: TypeExpectation) {}\n}\n\nexport function opt(type: TypeExpectation): Optional {\n  return new Optional(type);\n}\n\n/**\n * Asserts the runtime types of arguments. The 'expected' field can be one of\n * a class, a string (representing a \"typeof\" call), or a record map of name\n * to type. Furthermore, the opt() function can be used to mark a field as\n * optional. For example:\n *\n * function foo(auth: Auth, profile: {displayName?: string}, update = false) {\n *   assertTypes(arguments, [AuthImpl, {displayName: opt('string')}, opt('boolean')]);\n * }\n *\n * opt() can be used for any type:\n * function foo(auth?: Auth) {\n *   assertTypes(arguments, [opt(AuthImpl)]);\n * }\n *\n * The string types can be or'd together, and you can use \"null\" as well (note\n * that typeof null === 'object'; this is an edge case). For example:\n *\n * function foo(profile: {displayName?: string | null}) {\n *   assertTypes(arguments, [{displayName: opt('string|null')}]);\n * }\n *\n * @param args\n * @param expected\n */\nexport function assertTypes(\n  args: Omit<IArguments, 'callee'>,\n  ...expected: Array<TypeExpectation | Optional>\n): void {\n  if (args.length > expected.length) {\n    _fail(AuthErrorCode.ARGUMENT_ERROR, {});\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    let expect = expected[i];\n    const arg = args[i];\n\n    if (expect instanceof Optional) {\n      // If the arg is undefined, then it matches \"optional\" and we can move to\n      // the next arg\n      if (typeof arg === 'undefined') {\n        continue;\n      }\n      expect = expect.type;\n    }\n\n    if (typeof expect === 'string') {\n      // Handle the edge case for null because typeof null === 'object'\n      if (expect.includes('null') && arg === null) {\n        continue;\n      }\n\n      const required = expect.split('|');\n      _assert(required.includes(typeof arg), AuthErrorCode.ARGUMENT_ERROR, {});\n    } else if (typeof expect === 'object') {\n      // Recursively check record arguments\n      const record = arg as Record<string, unknown>;\n      const map = expect as MapType;\n      const keys = Object.keys(expect);\n\n      assertTypes(\n        keys.map(k => record[k]),\n        ...keys.map(k => map[k])\n      );\n    } else {\n      _assert(arg instanceof expect, AuthErrorCode.ARGUMENT_ERROR, {});\n    }\n  }\n}\n\n/**\n * Unconditionally fails, throwing an internal error with the given message.\n *\n * @param failure type of failure encountered\n * @throws Error\n */\nexport function debugFail(failure: string): never {\n  // Log the failure in addition to throw an exception, just in case the\n  // exception is swallowed.\n  const message = `INTERNAL ASSERTION FAILED: ` + failure;\n  _logError(message);\n\n  // NOTE: We don't use FirebaseError here because these are internal failures\n  // that cannot be handled by the user. (Also it would create a circular\n  // dependency between the error and assert modules which doesn't work.)\n  throw new Error(message);\n}\n\n/**\n * Fails if the given assertion condition is false, throwing an Error with the\n * given message if it did.\n *\n * @param assertion\n * @param message\n */\nexport function debugAssert(\n  assertion: unknown,\n  message: string\n): asserts assertion {\n  if (!assertion) {\n    debugFail(message);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function _getCurrentUrl(): string {\n  return (typeof self !== 'undefined' && self.location?.href) || '';\n}\n\nexport function _isHttpOrHttps(): boolean {\n  return _getCurrentScheme() === 'http:' || _getCurrentScheme() === 'https:';\n}\n\nexport function _getCurrentScheme(): string | null {\n  return (typeof self !== 'undefined' && self.location?.protocol) || null;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isBrowserExtension } from '@firebase/util';\nimport { _isHttpOrHttps } from './location';\n\n/**\n * Determine whether the browser is working online\n */\nexport function _isOnline(): boolean {\n  if (\n    typeof navigator !== 'undefined' &&\n    navigator &&\n    'onLine' in navigator &&\n    typeof navigator.onLine === 'boolean' &&\n    // Apply only for traditional web apps and Chrome extensions.\n    // This is especially true for Cordova apps which have unreliable\n    // navigator.onLine behavior unless cordova-plugin-network-information is\n    // installed which overwrites the native navigator.onLine value and\n    // defines navigator.connection.\n    (_isHttpOrHttps() || isBrowserExtension() || 'connection' in navigator)\n  ) {\n    return navigator.onLine;\n  }\n  // If we can't determine the state, assume it is online.\n  return true;\n}\n\nexport function _getUserLanguage(): string | null {\n  if (typeof navigator === 'undefined') {\n    return null;\n  }\n  const navigatorLanguage: NavigatorLanguage = navigator;\n  return (\n    // Most reliable, but only supported in Chrome/Firefox.\n    (navigatorLanguage.languages && navigatorLanguage.languages[0]) ||\n    // Supported in most browsers, but returns the language of the browser\n    // UI, not the language set in browser settings.\n    navigatorLanguage.language ||\n    // Couldn't determine language.\n    null\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isMobileCordova, isReactNative } from '@firebase/util';\nimport { _isOnline } from './navigator';\nimport { debugAssert } from './assert';\n\nexport const enum DelayMin {\n  OFFLINE = 5000\n}\n\n/**\n * A structure to help pick between a range of long and short delay durations\n * depending on the current environment. In general, the long delay is used for\n * mobile environments whereas short delays are used for desktop environments.\n */\nexport class Delay {\n  // The default value for the offline delay timeout in ms.\n\n  private readonly isMobile: boolean;\n  constructor(\n    private readonly shortDelay: number,\n    private readonly longDelay: number\n  ) {\n    // Internal error when improperly initialized.\n    debugAssert(\n      longDelay > shortDelay,\n      'Short delay should be less than long delay!'\n    );\n    this.isMobile = isMobileCordova() || isReactNative();\n  }\n\n  get(): number {\n    if (!_isOnline()) {\n      // Pick the shorter timeout.\n      return Math.min(DelayMin.OFFLINE, this.shortDelay);\n    }\n    // If running in a mobile environment, return the long delay, otherwise\n    // return the short delay.\n    // This could be improved in the future to dynamically change based on other\n    // variables instead of just reading the current environment.\n    return this.isMobile ? this.longDelay : this.shortDelay;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ConfigInternal } from '../../model/auth';\nimport { debugAssert } from './assert';\n\nexport function _emulatorUrl(config: ConfigInternal, path?: string): string {\n  debugAssert(config.emulator, 'Emulator should always be set here');\n  const { url } = config.emulator;\n\n  if (!path) {\n    return url;\n  }\n\n  return `${url}${path.startsWith('/') ? path.slice(1) : path}`;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debugFail } from './assert';\n\nexport class FetchProvider {\n  private static fetchImpl: typeof fetch | null;\n  private static headersImpl: typeof Headers | null;\n  private static responseImpl: typeof Response | null;\n\n  static initialize(\n    fetchImpl: typeof fetch,\n    headersImpl?: typeof Headers,\n    responseImpl?: typeof Response\n  ): void {\n    this.fetchImpl = fetchImpl;\n    if (headersImpl) {\n      this.headersImpl = headersImpl;\n    }\n    if (responseImpl) {\n      this.responseImpl = responseImpl;\n    }\n  }\n\n  static fetch(): typeof fetch {\n    if (this.fetchImpl) {\n      return this.fetchImpl;\n    }\n    if (typeof self !== 'undefined' && 'fetch' in self) {\n      return self.fetch;\n    }\n    if (typeof globalThis !== 'undefined' && globalThis.fetch) {\n      return globalThis.fetch;\n    }\n    if (typeof fetch !== 'undefined') {\n      return fetch;\n    }\n    debugFail(\n      'Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n\n  static headers(): typeof Headers {\n    if (this.headersImpl) {\n      return this.headersImpl;\n    }\n    if (typeof self !== 'undefined' && 'Headers' in self) {\n      return self.Headers;\n    }\n    if (typeof globalThis !== 'undefined' && globalThis.Headers) {\n      return globalThis.Headers;\n    }\n    if (typeof Headers !== 'undefined') {\n      return Headers;\n    }\n    debugFail(\n      'Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n\n  static response(): typeof Response {\n    if (this.responseImpl) {\n      return this.responseImpl;\n    }\n    if (typeof self !== 'undefined' && 'Response' in self) {\n      return self.Response;\n    }\n    if (typeof globalThis !== 'undefined' && globalThis.Response) {\n      return globalThis.Response;\n    }\n    if (typeof Response !== 'undefined') {\n      return Response;\n    }\n    debugFail(\n      'Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../core/errors';\n\n/**\n * Errors that can be returned by the backend\n */\nexport const enum ServerError {\n  ADMIN_ONLY_OPERATION = 'ADMIN_ONLY_OPERATION',\n  BLOCKING_FUNCTION_ERROR_RESPONSE = 'BLOCKING_FUNCTION_ERROR_RESPONSE',\n  CAPTCHA_CHECK_FAILED = 'CAPTCHA_CHECK_FAILED',\n  CORS_UNSUPPORTED = 'CORS_UNSUPPORTED',\n  CREDENTIAL_MISMATCH = 'CREDENTIAL_MISMATCH',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN = 'CREDENTIAL_TOO_OLD_LOGIN_AGAIN',\n  DYNAMIC_LINK_NOT_ACTIVATED = 'DYNAMIC_LINK_NOT_ACTIVATED',\n  EMAIL_CHANGE_NEEDS_VERIFICATION = 'EMAIL_CHANGE_NEEDS_VERIFICATION',\n  EMAIL_EXISTS = 'EMAIL_EXISTS',\n  EMAIL_NOT_FOUND = 'EMAIL_NOT_FOUND',\n  EXPIRED_OOB_CODE = 'EXPIRED_OOB_CODE',\n  FEDERATED_USER_ID_ALREADY_LINKED = 'FEDERATED_USER_ID_ALREADY_LINKED',\n  INVALID_APP_CREDENTIAL = 'INVALID_APP_CREDENTIAL',\n  INVALID_APP_ID = 'INVALID_APP_ID',\n  INVALID_CERT_HASH = 'INVALID_CERT_HASH',\n  INVALID_CODE = 'INVALID_CODE',\n  INVALID_CONTINUE_URI = 'INVALID_CONTINUE_URI',\n  INVALID_CUSTOM_TOKEN = 'INVALID_CUSTOM_TOKEN',\n  INVALID_DYNAMIC_LINK_DOMAIN = 'INVALID_DYNAMIC_LINK_DOMAIN',\n  INVALID_EMAIL = 'INVALID_EMAIL',\n  INVALID_ID_TOKEN = 'INVALID_ID_TOKEN',\n  INVALID_IDP_RESPONSE = 'INVALID_IDP_RESPONSE',\n  INVALID_IDENTIFIER = 'INVALID_IDENTIFIER',\n  INVALID_LOGIN_CREDENTIALS = 'INVALID_LOGIN_CREDENTIALS',\n  INVALID_MESSAGE_PAYLOAD = 'INVALID_MESSAGE_PAYLOAD',\n  INVALID_MFA_PENDING_CREDENTIAL = 'INVALID_MFA_PENDING_CREDENTIAL',\n  INVALID_OAUTH_CLIENT_ID = 'INVALID_OAUTH_CLIENT_ID',\n  INVALID_OOB_CODE = 'INVALID_OOB_CODE',\n  INVALID_PASSWORD = 'INVALID_PASSWORD',\n  INVALID_PENDING_TOKEN = 'INVALID_PENDING_TOKEN',\n  INVALID_PHONE_NUMBER = 'INVALID_PHONE_NUMBER',\n  INVALID_PROVIDER_ID = 'INVALID_PROVIDER_ID',\n  INVALID_RECIPIENT_EMAIL = 'INVALID_RECIPIENT_EMAIL',\n  INVALID_SENDER = 'INVALID_SENDER',\n  INVALID_SESSION_INFO = 'INVALID_SESSION_INFO',\n  INVALID_TEMPORARY_PROOF = 'INVALID_TEMPORARY_PROOF',\n  INVALID_TENANT_ID = 'INVALID_TENANT_ID',\n  MFA_ENROLLMENT_NOT_FOUND = 'MFA_ENROLLMENT_NOT_FOUND',\n  MISSING_ANDROID_PACKAGE_NAME = 'MISSING_ANDROID_PACKAGE_NAME',\n  MISSING_APP_CREDENTIAL = 'MISSING_APP_CREDENTIAL',\n  MISSING_CODE = 'MISSING_CODE',\n  MISSING_CONTINUE_URI = 'MISSING_CONTINUE_URI',\n  MISSING_CUSTOM_TOKEN = 'MISSING_CUSTOM_TOKEN',\n  MISSING_IOS_BUNDLE_ID = 'MISSING_IOS_BUNDLE_ID',\n  MISSING_MFA_ENROLLMENT_ID = 'MISSING_MFA_ENROLLMENT_ID',\n  MISSING_MFA_PENDING_CREDENTIAL = 'MISSING_MFA_PENDING_CREDENTIAL',\n  MISSING_OOB_CODE = 'MISSING_OOB_CODE',\n  MISSING_OR_INVALID_NONCE = 'MISSING_OR_INVALID_NONCE',\n  MISSING_PASSWORD = 'MISSING_PASSWORD',\n  MISSING_REQ_TYPE = 'MISSING_REQ_TYPE',\n  MISSING_PHONE_NUMBER = 'MISSING_PHONE_NUMBER',\n  MISSING_SESSION_INFO = 'MISSING_SESSION_INFO',\n  OPERATION_NOT_ALLOWED = 'OPERATION_NOT_ALLOWED',\n  PASSWORD_LOGIN_DISABLED = 'PASSWORD_LOGIN_DISABLED',\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RESET_PASSWORD_EXCEED_LIMIT = 'RESET_PASSWORD_EXCEED_LIMIT',\n  REJECTED_CREDENTIAL = 'REJECTED_CREDENTIAL',\n  SECOND_FACTOR_EXISTS = 'SECOND_FACTOR_EXISTS',\n  SECOND_FACTOR_LIMIT_EXCEEDED = 'SECOND_FACTOR_LIMIT_EXCEEDED',\n  SESSION_EXPIRED = 'SESSION_EXPIRED',\n  TENANT_ID_MISMATCH = 'TENANT_ID_MISMATCH',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOO_MANY_ATTEMPTS_TRY_LATER = 'TOO_MANY_ATTEMPTS_TRY_LATER',\n  UNSUPPORTED_FIRST_FACTOR = 'UNSUPPORTED_FIRST_FACTOR',\n  UNSUPPORTED_TENANT_OPERATION = 'UNSUPPORTED_TENANT_OPERATION',\n  UNAUTHORIZED_DOMAIN = 'UNAUTHORIZED_DOMAIN',\n  UNVERIFIED_EMAIL = 'UNVERIFIED_EMAIL',\n  USER_CANCELLED = 'USER_CANCELLED',\n  USER_DISABLED = 'USER_DISABLED',\n  USER_NOT_FOUND = 'USER_NOT_FOUND',\n  WEAK_PASSWORD = 'WEAK_PASSWORD',\n  RECAPTCHA_NOT_ENABLED = 'RECAPTCHA_NOT_ENABLED',\n  MISSING_RECAPTCHA_TOKEN = 'MISSING_RECAPTCHA_TOKEN',\n  INVALID_RECAPTCHA_TOKEN = 'INVALID_RECAPTCHA_TOKEN',\n  INVALID_RECAPTCHA_ACTION = 'INVALID_RECAPTCHA_ACTION',\n  MISSING_CLIENT_TYPE = 'MISSING_CLIENT_TYPE',\n  MISSING_RECAPTCHA_VERSION = 'MISSING_RECAPTCHA_VERSION',\n  INVALID_RECAPTCHA_VERSION = 'INVALID_RECAPTCHA_VERSION',\n  INVALID_REQ_TYPE = 'INVALID_REQ_TYPE',\n  PASSWORD_DOES_NOT_MEET_REQUIREMENTS = 'PASSWORD_DOES_NOT_MEET_REQUIREMENTS',\n  INVALID_HOSTING_LINK_DOMAIN = 'INVALID_HOSTING_LINK_DOMAIN'\n}\n\n/**\n * API Response in the event of an error\n */\nexport interface JsonError {\n  error: {\n    code: number;\n    message: string;\n    errors?: [\n      {\n        message: ServerError;\n        domain: string;\n        reason: string;\n      }\n    ];\n  };\n}\n\n/**\n * Type definition for a map from server errors to developer visible errors\n */\nexport declare type ServerErrorMap<ApiError extends string> = {\n  readonly [K in ApiError]: AuthErrorCode;\n};\n\n/**\n * Map from errors returned by the server to errors to developer visible errors\n */\nexport const SERVER_ERROR_MAP: Partial<ServerErrorMap<ServerError>> = {\n  // Custom token errors.\n  [ServerError.CREDENTIAL_MISMATCH]: AuthErrorCode.CREDENTIAL_MISMATCH,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_CUSTOM_TOKEN]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Create Auth URI errors.\n  [ServerError.INVALID_IDENTIFIER]: AuthErrorCode.INVALID_EMAIL,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_CONTINUE_URI]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Sign in with email and password errors (some apply to sign up too).\n  [ServerError.INVALID_PASSWORD]: AuthErrorCode.INVALID_PASSWORD,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_PASSWORD]: AuthErrorCode.MISSING_PASSWORD,\n  // Thrown if Email Enumeration Protection is enabled in the project and the email or password is\n  // invalid.\n  [ServerError.INVALID_LOGIN_CREDENTIALS]: AuthErrorCode.INVALID_CREDENTIAL,\n\n  // Sign up with email and password errors.\n  [ServerError.EMAIL_EXISTS]: AuthErrorCode.EMAIL_EXISTS,\n  [ServerError.PASSWORD_LOGIN_DISABLED]: AuthErrorCode.OPERATION_NOT_ALLOWED,\n\n  // Verify assertion for sign in with credential errors:\n  [ServerError.INVALID_IDP_RESPONSE]: AuthErrorCode.INVALID_CREDENTIAL,\n  [ServerError.INVALID_PENDING_TOKEN]: AuthErrorCode.INVALID_CREDENTIAL,\n  [ServerError.FEDERATED_USER_ID_ALREADY_LINKED]:\n    AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,\n\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_REQ_TYPE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Send Password reset email errors:\n  [ServerError.EMAIL_NOT_FOUND]: AuthErrorCode.USER_DELETED,\n  [ServerError.RESET_PASSWORD_EXCEED_LIMIT]:\n    AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER,\n\n  [ServerError.EXPIRED_OOB_CODE]: AuthErrorCode.EXPIRED_OOB_CODE,\n  [ServerError.INVALID_OOB_CODE]: AuthErrorCode.INVALID_OOB_CODE,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_OOB_CODE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Operations that require ID token in request:\n  [ServerError.CREDENTIAL_TOO_OLD_LOGIN_AGAIN]:\n    AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN,\n  [ServerError.INVALID_ID_TOKEN]: AuthErrorCode.INVALID_AUTH,\n  [ServerError.TOKEN_EXPIRED]: AuthErrorCode.TOKEN_EXPIRED,\n  [ServerError.USER_NOT_FOUND]: AuthErrorCode.TOKEN_EXPIRED,\n\n  // Other errors.\n  [ServerError.TOO_MANY_ATTEMPTS_TRY_LATER]:\n    AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER,\n  [ServerError.PASSWORD_DOES_NOT_MEET_REQUIREMENTS]:\n    AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS,\n\n  // Phone Auth related errors.\n  [ServerError.INVALID_CODE]: AuthErrorCode.INVALID_CODE,\n  [ServerError.INVALID_SESSION_INFO]: AuthErrorCode.INVALID_SESSION_INFO,\n  [ServerError.INVALID_TEMPORARY_PROOF]: AuthErrorCode.INVALID_CREDENTIAL,\n  [ServerError.MISSING_SESSION_INFO]: AuthErrorCode.MISSING_SESSION_INFO,\n  [ServerError.SESSION_EXPIRED]: AuthErrorCode.CODE_EXPIRED,\n\n  // Other action code errors when additional settings passed.\n  // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.\n  // This is OK as this error will be caught by client side validation.\n  [ServerError.MISSING_ANDROID_PACKAGE_NAME]:\n    AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME,\n  [ServerError.UNAUTHORIZED_DOMAIN]: AuthErrorCode.UNAUTHORIZED_DOMAIN,\n\n  // getProjectConfig errors when clientId is passed.\n  [ServerError.INVALID_OAUTH_CLIENT_ID]: AuthErrorCode.INVALID_OAUTH_CLIENT_ID,\n\n  // User actions (sign-up or deletion) disabled errors.\n  [ServerError.ADMIN_ONLY_OPERATION]: AuthErrorCode.ADMIN_ONLY_OPERATION,\n\n  // Multi factor related errors.\n  [ServerError.INVALID_MFA_PENDING_CREDENTIAL]:\n    AuthErrorCode.INVALID_MFA_SESSION,\n  [ServerError.MFA_ENROLLMENT_NOT_FOUND]: AuthErrorCode.MFA_INFO_NOT_FOUND,\n  [ServerError.MISSING_MFA_ENROLLMENT_ID]: AuthErrorCode.MISSING_MFA_INFO,\n  [ServerError.MISSING_MFA_PENDING_CREDENTIAL]:\n    AuthErrorCode.MISSING_MFA_SESSION,\n  [ServerError.SECOND_FACTOR_EXISTS]:\n    AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED,\n  [ServerError.SECOND_FACTOR_LIMIT_EXCEEDED]:\n    AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED,\n\n  // Blocking functions related errors.\n  [ServerError.BLOCKING_FUNCTION_ERROR_RESPONSE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Recaptcha related errors.\n  [ServerError.RECAPTCHA_NOT_ENABLED]: AuthErrorCode.RECAPTCHA_NOT_ENABLED,\n  [ServerError.MISSING_RECAPTCHA_TOKEN]: AuthErrorCode.MISSING_RECAPTCHA_TOKEN,\n  [ServerError.INVALID_RECAPTCHA_TOKEN]: AuthErrorCode.INVALID_RECAPTCHA_TOKEN,\n  [ServerError.INVALID_RECAPTCHA_ACTION]:\n    AuthErrorCode.INVALID_RECAPTCHA_ACTION,\n  [ServerError.MISSING_CLIENT_TYPE]: AuthErrorCode.MISSING_CLIENT_TYPE,\n  [ServerError.MISSING_RECAPTCHA_VERSION]:\n    AuthErrorCode.MISSING_RECAPTCHA_VERSION,\n  [ServerError.INVALID_RECAPTCHA_VERSION]:\n    AuthErrorCode.INVALID_RECAPTCHA_VERSION,\n  [ServerError.INVALID_REQ_TYPE]: AuthErrorCode.INVALID_REQ_TYPE\n};\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseError,\n  isCloudflareWorker,\n  isCloudWorkstation,\n  querystring\n} from '@firebase/util';\n\nimport { AuthErrorCode, NamedErrorParams } from '../core/errors';\nimport {\n  _createError,\n  _errorWithCustomMessage,\n  _fail\n} from '../core/util/assert';\nimport { Delay } from '../core/util/delay';\nimport { _emulatorUrl } from '../core/util/emulator';\nimport { FetchProvider } from '../core/util/fetch_provider';\nimport { Auth } from '../model/public_types';\nimport { AuthInternal, ConfigInternal } from '../model/auth';\nimport { IdTokenResponse, TaggedWithTokenResponse } from '../model/id_token';\nimport { IdTokenMfaResponse } from './authentication/mfa';\nimport { SERVER_ERROR_MAP, ServerError, ServerErrorMap } from './errors';\nimport { PersistenceType } from '../core/persistence';\nimport { CookiePersistence } from '../platform_browser/persistence/cookie_storage';\n\nexport const enum HttpMethod {\n  POST = 'POST',\n  GET = 'GET'\n}\n\nexport const enum HttpHeader {\n  CONTENT_TYPE = 'Content-Type',\n  X_FIREBASE_LOCALE = 'X-Firebase-Locale',\n  X_CLIENT_VERSION = 'X-Client-Version',\n  X_FIREBASE_GMPID = 'X-Firebase-gmpid',\n  X_FIREBASE_CLIENT = 'X-Firebase-Client',\n  X_FIREBASE_APP_CHECK = 'X-Firebase-AppCheck'\n}\n\nexport const enum Endpoint {\n  CREATE_AUTH_URI = '/v1/accounts:createAuthUri',\n  DELETE_ACCOUNT = '/v1/accounts:delete',\n  RESET_PASSWORD = '/v1/accounts:resetPassword',\n  SIGN_UP = '/v1/accounts:signUp',\n  SIGN_IN_WITH_CUSTOM_TOKEN = '/v1/accounts:signInWithCustomToken',\n  SIGN_IN_WITH_EMAIL_LINK = '/v1/accounts:signInWithEmailLink',\n  SIGN_IN_WITH_IDP = '/v1/accounts:signInWithIdp',\n  SIGN_IN_WITH_PASSWORD = '/v1/accounts:signInWithPassword',\n  SIGN_IN_WITH_PHONE_NUMBER = '/v1/accounts:signInWithPhoneNumber',\n  SEND_VERIFICATION_CODE = '/v1/accounts:sendVerificationCode',\n  SEND_OOB_CODE = '/v1/accounts:sendOobCode',\n  SET_ACCOUNT_INFO = '/v1/accounts:update',\n  GET_ACCOUNT_INFO = '/v1/accounts:lookup',\n  GET_RECAPTCHA_PARAM = '/v1/recaptchaParams',\n  START_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:start',\n  FINALIZE_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:finalize',\n  START_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:start',\n  FINALIZE_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:finalize',\n  WITHDRAW_MFA = '/v2/accounts/mfaEnrollment:withdraw',\n  GET_PROJECT_CONFIG = '/v1/projects',\n  GET_RECAPTCHA_CONFIG = '/v2/recaptchaConfig',\n  GET_PASSWORD_POLICY = '/v2/passwordPolicy',\n  TOKEN = '/v1/token',\n  REVOKE_TOKEN = '/v2/accounts:revokeToken'\n}\n\nconst CookieAuthProxiedEndpoints: string[] = [\n  Endpoint.SIGN_IN_WITH_CUSTOM_TOKEN,\n  Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n  Endpoint.SIGN_IN_WITH_IDP,\n  Endpoint.SIGN_IN_WITH_PASSWORD,\n  Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n  Endpoint.TOKEN\n];\n\nexport const enum RecaptchaClientType {\n  WEB = 'CLIENT_TYPE_WEB',\n  ANDROID = 'CLIENT_TYPE_ANDROID',\n  IOS = 'CLIENT_TYPE_IOS'\n}\n\nexport const enum RecaptchaVersion {\n  ENTERPRISE = 'RECAPTCHA_ENTERPRISE'\n}\n\nexport const enum RecaptchaActionName {\n  SIGN_IN_WITH_PASSWORD = 'signInWithPassword',\n  GET_OOB_CODE = 'getOobCode',\n  SIGN_UP_PASSWORD = 'signUpPassword',\n  SEND_VERIFICATION_CODE = 'sendVerificationCode',\n  MFA_SMS_ENROLLMENT = 'mfaSmsEnrollment',\n  MFA_SMS_SIGNIN = 'mfaSmsSignIn'\n}\n\nexport const enum EnforcementState {\n  ENFORCE = 'ENFORCE',\n  AUDIT = 'AUDIT',\n  OFF = 'OFF',\n  ENFORCEMENT_STATE_UNSPECIFIED = 'ENFORCEMENT_STATE_UNSPECIFIED'\n}\n\n// Providers that have reCAPTCHA Enterprise support.\nexport const enum RecaptchaAuthProvider {\n  EMAIL_PASSWORD_PROVIDER = 'EMAIL_PASSWORD_PROVIDER',\n  PHONE_PROVIDER = 'PHONE_PROVIDER'\n}\n\nexport const DEFAULT_API_TIMEOUT_MS = new Delay(30_000, 60_000);\n\nexport function _addTidIfNecessary<T extends { tenantId?: string }>(\n  auth: Auth,\n  request: T\n): T {\n  if (auth.tenantId && !request.tenantId) {\n    return {\n      ...request,\n      tenantId: auth.tenantId\n    };\n  }\n  return request;\n}\n\nexport async function _performApiRequest<T, V>(\n  auth: Auth,\n  method: HttpMethod,\n  path: Endpoint,\n  request?: T,\n  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}\n): Promise<V> {\n  return _performFetchWithErrorHandling(auth, customErrorMap, async () => {\n    let body = {};\n    let params = {};\n    if (request) {\n      if (method === HttpMethod.GET) {\n        params = request;\n      } else {\n        body = {\n          body: JSON.stringify(request)\n        };\n      }\n    }\n\n    const query = querystring({\n      key: auth.config.apiKey,\n      ...params\n    }).slice(1);\n\n    const headers = await (auth as AuthInternal)._getAdditionalHeaders();\n    headers[HttpHeader.CONTENT_TYPE] = 'application/json';\n\n    if (auth.languageCode) {\n      headers[HttpHeader.X_FIREBASE_LOCALE] = auth.languageCode;\n    }\n\n    const fetchArgs: RequestInit = {\n      method,\n      headers,\n      ...body\n    };\n\n    /* Security-conscious server-side frameworks tend to have built in mitigations for referrer\n       problems\". See the Cloudflare GitHub issue #487: Error: The 'referrerPolicy' field on\n       'RequestInitializerDict' is not implemented.\"\n       https://github.com/cloudflare/next-on-pages/issues/487 */\n    if (!isCloudflareWorker()) {\n      fetchArgs.referrerPolicy = 'no-referrer';\n    }\n\n    if (auth.emulatorConfig && isCloudWorkstation(auth.emulatorConfig.host)) {\n      fetchArgs.credentials = 'include';\n    }\n\n    return FetchProvider.fetch()(\n      await _getFinalTarget(auth, auth.config.apiHost, path, query),\n      fetchArgs\n    );\n  });\n}\n\nexport async function _performFetchWithErrorHandling<V>(\n  auth: Auth,\n  customErrorMap: Partial<ServerErrorMap<ServerError>>,\n  fetchFn: () => Promise<Response>\n): Promise<V> {\n  (auth as AuthInternal)._canInitEmulator = false;\n  const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };\n  try {\n    const networkTimeout = new NetworkTimeout<Response>(auth);\n    const response: Response = await Promise.race<Promise<Response>>([\n      fetchFn(),\n      networkTimeout.promise\n    ]);\n\n    // If we've reached this point, the fetch succeeded and the networkTimeout\n    // didn't throw; clear the network timeout delay so that Node won't hang\n    networkTimeout.clearNetworkTimeout();\n\n    const json = await response.json();\n    if ('needConfirmation' in json) {\n      throw _makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, json);\n    }\n\n    if (response.ok && !('errorMessage' in json)) {\n      return json;\n    } else {\n      const errorMessage = response.ok ? json.errorMessage : json.error.message;\n      const [serverErrorCode, serverErrorMessage] = errorMessage.split(' : ');\n      if (serverErrorCode === ServerError.FEDERATED_USER_ID_ALREADY_LINKED) {\n        throw _makeTaggedError(\n          auth,\n          AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,\n          json\n        );\n      } else if (serverErrorCode === ServerError.EMAIL_EXISTS) {\n        throw _makeTaggedError(auth, AuthErrorCode.EMAIL_EXISTS, json);\n      } else if (serverErrorCode === ServerError.USER_DISABLED) {\n        throw _makeTaggedError(auth, AuthErrorCode.USER_DISABLED, json);\n      }\n      const authError =\n        errorMap[serverErrorCode as ServerError] ||\n        (serverErrorCode\n          .toLowerCase()\n          .replace(/[_\\s]+/g, '-') as unknown as AuthErrorCode);\n      if (serverErrorMessage) {\n        throw _errorWithCustomMessage(auth, authError, serverErrorMessage);\n      } else {\n        _fail(auth, authError);\n      }\n    }\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      throw e;\n    }\n    // Changing this to a different error code will log user out when there is a network error\n    // because we treat any error other than NETWORK_REQUEST_FAILED as token is invalid.\n    // https://github.com/firebase/firebase-js-sdk/blob/4fbc73610d70be4e0852e7de63a39cb7897e8546/packages/auth/src/core/auth/auth_impl.ts#L309-L316\n    _fail(auth, AuthErrorCode.NETWORK_REQUEST_FAILED, { 'message': String(e) });\n  }\n}\n\nexport async function _performSignInRequest<T, V extends IdTokenResponse>(\n  auth: Auth,\n  method: HttpMethod,\n  path: Endpoint,\n  request?: T,\n  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}\n): Promise<V> {\n  const serverResponse = await _performApiRequest<T, V | IdTokenMfaResponse>(\n    auth,\n    method,\n    path,\n    request,\n    customErrorMap\n  );\n  if ('mfaPendingCredential' in serverResponse) {\n    _fail(auth, AuthErrorCode.MFA_REQUIRED, {\n      _serverResponse: serverResponse\n    });\n  }\n\n  return serverResponse as V;\n}\n\nexport async function _getFinalTarget(\n  auth: Auth,\n  host: string,\n  path: string,\n  query: string\n): Promise<string> {\n  const base = `${host}${path}?${query}`;\n\n  const authInternal = auth as AuthInternal;\n  const finalTarget = authInternal.config.emulator\n    ? _emulatorUrl(auth.config as ConfigInternal, base)\n    : `${auth.config.apiScheme}://${base}`;\n\n  // Cookie auth works by MiTMing the signIn and token endpoints from the developer's backend,\n  // saving the idToken and refreshToken into cookies, and then redacting the refreshToken\n  // from the response\n  if (CookieAuthProxiedEndpoints.includes(path)) {\n    // Persistence manager is async, we need to await it. We can't just wait for auth initialized\n    // here since auth initialization calls this function.\n    await authInternal._persistenceManagerAvailable;\n    if (authInternal._getPersistenceType() === PersistenceType.COOKIE) {\n      const cookiePersistence =\n        authInternal._getPersistence() as CookiePersistence;\n      return cookiePersistence._getFinalTarget(finalTarget).toString();\n    }\n  }\n\n  return finalTarget;\n}\n\nexport function _parseEnforcementState(\n  enforcementStateStr: string\n): EnforcementState {\n  switch (enforcementStateStr) {\n    case 'ENFORCE':\n      return EnforcementState.ENFORCE;\n    case 'AUDIT':\n      return EnforcementState.AUDIT;\n    case 'OFF':\n      return EnforcementState.OFF;\n    default:\n      return EnforcementState.ENFORCEMENT_STATE_UNSPECIFIED;\n  }\n}\n\nclass NetworkTimeout<T> {\n  // Node timers and browser timers are fundamentally incompatible, but we\n  // don't care about the value here\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private timer: any | null = null;\n  readonly promise = new Promise<T>((_, reject) => {\n    this.timer = setTimeout(() => {\n      return reject(\n        _createError(this.auth, AuthErrorCode.NETWORK_REQUEST_FAILED)\n      );\n    }, DEFAULT_API_TIMEOUT_MS.get());\n  });\n\n  clearNetworkTimeout(): void {\n    clearTimeout(this.timer);\n  }\n\n  constructor(private readonly auth: Auth) {}\n}\n\ninterface PotentialResponse extends IdTokenResponse {\n  email?: string;\n  phoneNumber?: string;\n}\n\nexport function _makeTaggedError(\n  auth: Auth,\n  code: AuthErrorCode,\n  response: PotentialResponse\n): FirebaseError {\n  const errorParams: NamedErrorParams = {\n    appName: auth.name\n  };\n\n  if (response.email) {\n    errorParams.email = response.email;\n  }\n  if (response.phoneNumber) {\n    errorParams.phoneNumber = response.phoneNumber;\n  }\n\n  const error = _createError(auth, code, errorParams);\n\n  // We know customData is defined on error because errorParams is defined\n  (error.customData! as TaggedWithTokenResponse)._tokenResponse = response;\n  return error;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { RecaptchaParameters } from '../../model/public_types';\nimport {\n  GetRecaptchaConfigResponse,\n  RecaptchaEnforcementProviderState\n} from '../../api/authentication/recaptcha';\nimport {\n  EnforcementState,\n  RecaptchaAuthProvider,\n  _parseEnforcementState\n} from '../../api/index';\n\n// reCAPTCHA v2 interface\nexport interface Recaptcha {\n  render: (container: HTMLElement, parameters: RecaptchaParameters) => number;\n  getResponse: (id: number) => string;\n  execute: (id: number) => unknown;\n  reset: (id: number) => unknown;\n}\n\nexport function isV2(\n  grecaptcha: Recaptcha | GreCAPTCHA | undefined\n): grecaptcha is Recaptcha {\n  return (\n    grecaptcha !== undefined &&\n    (grecaptcha as Recaptcha).getResponse !== undefined\n  );\n}\n\n// reCAPTCHA Enterprise & v3 shared interface\nexport interface GreCAPTCHATopLevel extends GreCAPTCHA {\n  enterprise: GreCAPTCHA;\n}\n\n// reCAPTCHA Enterprise interface\nexport interface GreCAPTCHA {\n  ready: (callback: () => void) => void;\n  execute: (siteKey: string, options: { action: string }) => Promise<string>;\n  render: (\n    container: string | HTMLElement,\n    parameters: GreCAPTCHARenderOption\n  ) => string;\n}\n\nexport interface GreCAPTCHARenderOption {\n  sitekey: string;\n  size: 'invisible';\n}\n\nexport function isEnterprise(\n  grecaptcha: Recaptcha | GreCAPTCHA | undefined\n): grecaptcha is GreCAPTCHATopLevel {\n  return (\n    grecaptcha !== undefined &&\n    (grecaptcha as GreCAPTCHATopLevel).enterprise !== undefined\n  );\n}\n\n// TODO(chuanr): Replace this with the AuthWindow after resolving the dependency issue in Node.js env.\ndeclare global {\n  interface Window {\n    grecaptcha?: Recaptcha | GreCAPTCHATopLevel;\n  }\n}\n\nexport class RecaptchaConfig {\n  /**\n   * The reCAPTCHA site key.\n   */\n  siteKey: string = '';\n\n  /**\n   * The list of providers and their enablement status for reCAPTCHA Enterprise.\n   */\n  recaptchaEnforcementState: RecaptchaEnforcementProviderState[] = [];\n\n  constructor(response: GetRecaptchaConfigResponse) {\n    if (response.recaptchaKey === undefined) {\n      throw new Error('recaptchaKey undefined');\n    }\n    // Example response.recaptchaKey: \"projects/proj123/keys/sitekey123\"\n    this.siteKey = response.recaptchaKey.split('/')[3];\n    this.recaptchaEnforcementState = response.recaptchaEnforcementState;\n  }\n\n  /**\n   * Returns the reCAPTCHA Enterprise enforcement state for the given provider.\n   *\n   * @param providerStr - The provider whose enforcement state is to be returned.\n   * @returns The reCAPTCHA Enterprise enforcement state for the given provider.\n   */\n  getProviderEnforcementState(providerStr: string): EnforcementState | null {\n    if (\n      !this.recaptchaEnforcementState ||\n      this.recaptchaEnforcementState.length === 0\n    ) {\n      return null;\n    }\n\n    for (const recaptchaEnforcementState of this.recaptchaEnforcementState) {\n      if (\n        recaptchaEnforcementState.provider &&\n        recaptchaEnforcementState.provider === providerStr\n      ) {\n        return _parseEnforcementState(\n          recaptchaEnforcementState.enforcementState\n        );\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Returns true if the reCAPTCHA Enterprise enforcement state for the provider is set to ENFORCE or AUDIT.\n   *\n   * @param providerStr - The provider whose enablement state is to be returned.\n   * @returns Whether or not reCAPTCHA Enterprise protection is enabled for the given provider.\n   */\n  isProviderEnabled(providerStr: string): boolean {\n    return (\n      this.getProviderEnforcementState(providerStr) ===\n        EnforcementState.ENFORCE ||\n      this.getProviderEnforcementState(providerStr) === EnforcementState.AUDIT\n    );\n  }\n\n  /**\n   * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise\n   * returns false.\n   *\n   * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.\n   */\n  isAnyProviderEnabled(): boolean {\n    return (\n      this.isProviderEnabled(RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER) ||\n      this.isProviderEnabled(RecaptchaAuthProvider.PHONE_PROVIDER)\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _performApiRequest,\n  _addTidIfNecessary\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\ninterface GetRecaptchaParamResponse {\n  recaptchaSiteKey?: string;\n}\n\nexport async function getRecaptchaParams(auth: Auth): Promise<string> {\n  return (\n    (\n      await _performApiRequest<void, GetRecaptchaParamResponse>(\n        auth,\n        HttpMethod.GET,\n        Endpoint.GET_RECAPTCHA_PARAM\n      )\n    ).recaptchaSiteKey || ''\n  );\n}\n\n// The following functions are for reCAPTCHA enterprise integration.\ninterface GetRecaptchaConfigRequest {\n  tenantId?: string;\n  clientType?: RecaptchaClientType;\n  version?: RecaptchaVersion;\n}\n\nexport interface RecaptchaEnforcementProviderState {\n  provider: string;\n  enforcementState: string;\n}\n\nexport interface GetRecaptchaConfigResponse {\n  recaptchaKey: string;\n  recaptchaEnforcementState: RecaptchaEnforcementProviderState[];\n}\n\nexport async function getRecaptchaConfig(\n  auth: Auth,\n  request: GetRecaptchaConfigRequest\n): Promise<GetRecaptchaConfigResponse> {\n  return _performApiRequest<\n    GetRecaptchaConfigRequest,\n    GetRecaptchaConfigResponse\n  >(\n    auth,\n    HttpMethod.GET,\n    Endpoint.GET_RECAPTCHA_CONFIG,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { MfaEnrollment } from './mfa';\nimport { Auth } from '../../model/public_types';\n\nexport interface DeleteAccountRequest {\n  idToken: string;\n}\n\nexport async function deleteAccount(\n  auth: Auth,\n  request: DeleteAccountRequest\n): Promise<void> {\n  return _performApiRequest<DeleteAccountRequest, void>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.DELETE_ACCOUNT,\n    request\n  );\n}\n\nexport interface ProviderUserInfo {\n  providerId: string;\n  rawId?: string;\n  email?: string;\n  displayName?: string;\n  photoUrl?: string;\n  phoneNumber?: string;\n}\n\nexport interface DeleteLinkedAccountsRequest {\n  idToken: string;\n  deleteProvider: string[];\n}\n\nexport interface DeleteLinkedAccountsResponse {\n  providerUserInfo: ProviderUserInfo[];\n}\n\nexport async function deleteLinkedAccounts(\n  auth: Auth,\n  request: DeleteLinkedAccountsRequest\n): Promise<DeleteLinkedAccountsResponse> {\n  return _performApiRequest<\n    DeleteLinkedAccountsRequest,\n    DeleteLinkedAccountsResponse\n  >(auth, HttpMethod.POST, Endpoint.SET_ACCOUNT_INFO, request);\n}\n\nexport interface APIUserInfo {\n  localId?: string;\n  displayName?: string;\n  photoUrl?: string;\n  email?: string;\n  emailVerified?: boolean;\n  phoneNumber?: string;\n  lastLoginAt?: number;\n  createdAt?: number;\n  tenantId?: string;\n  passwordHash?: string;\n  providerUserInfo?: ProviderUserInfo[];\n  mfaInfo?: MfaEnrollment[];\n}\n\nexport interface GetAccountInfoRequest {\n  idToken: string;\n}\n\nexport interface GetAccountInfoResponse {\n  users: APIUserInfo[];\n}\n\nexport async function getAccountInfo(\n  auth: Auth,\n  request: GetAccountInfoRequest\n): Promise<GetAccountInfoResponse> {\n  return _performApiRequest<GetAccountInfoRequest, GetAccountInfoResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.GET_ACCOUNT_INFO,\n    request\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function utcTimestampToDateString(\n  utcTimestamp?: string | number\n): string | undefined {\n  if (!utcTimestamp) {\n    return undefined;\n  }\n  try {\n    // Convert to date object.\n    const date = new Date(Number(utcTimestamp));\n    // Test date is valid.\n    if (!isNaN(date.getTime())) {\n      // Convert to UTC date string.\n      return date.toUTCString();\n    }\n  } catch (e) {\n    // Do nothing. undefined will be returned.\n  }\n  return undefined;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IdTokenResult, ParsedToken, User } from '../../model/public_types';\nimport { base64Decode, getModularInstance } from '@firebase/util';\n\nimport { UserInternal } from '../../model/user';\nimport { _assert } from '../util/assert';\nimport { _logError } from '../util/log';\nimport { utcTimestampToDateString } from '../util/time';\nimport { AuthErrorCode } from '../errors';\n\n/**\n * Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.\n *\n * @remarks\n * Returns the current token if it has not expired or if it will not expire in the next five\n * minutes. Otherwise, this will refresh the token and return a new one.\n *\n * @param user - The user.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport function getIdToken(user: User, forceRefresh = false): Promise<string> {\n  return getModularInstance(user).getIdToken(forceRefresh);\n}\n\n/**\n * Returns a deserialized JSON Web Token (JWT) used to identify the user to a Firebase service.\n *\n * @remarks\n * Returns the current token if it has not expired or if it will not expire in the next five\n * minutes. Otherwise, this will refresh the token and return a new one.\n *\n * @param user - The user.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport async function getIdTokenResult(\n  user: User,\n  forceRefresh = false\n): Promise<IdTokenResult> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const token = await userInternal.getIdToken(forceRefresh);\n  const claims = _parseToken(token);\n\n  _assert(\n    claims && claims.exp && claims.auth_time && claims.iat,\n    userInternal.auth,\n    AuthErrorCode.INTERNAL_ERROR\n  );\n  const firebase =\n    typeof claims.firebase === 'object' ? claims.firebase : undefined;\n\n  const signInProvider: string | undefined = firebase?.['sign_in_provider'];\n\n  return {\n    claims,\n    token,\n    authTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.auth_time)\n    )!,\n    issuedAtTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.iat)\n    )!,\n    expirationTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.exp)\n    )!,\n    signInProvider: signInProvider || null,\n    signInSecondFactor: firebase?.['sign_in_second_factor'] || null\n  };\n}\n\nfunction secondsStringToMilliseconds(seconds: string): number {\n  return Number(seconds) * 1000;\n}\n\nexport function _parseToken(token: string): ParsedToken | null {\n  const [algorithm, payload, signature] = token.split('.');\n  if (\n    algorithm === undefined ||\n    payload === undefined ||\n    signature === undefined\n  ) {\n    _logError('JWT malformed, contained fewer than 3 sections');\n    return null;\n  }\n\n  try {\n    const decoded = base64Decode(payload);\n    if (!decoded) {\n      _logError('Failed to decode base64 JWT payload');\n      return null;\n    }\n    return JSON.parse(decoded);\n  } catch (e) {\n    _logError(\n      'Caught error parsing JWT payload as JSON',\n      (e as Error)?.toString()\n    );\n    return null;\n  }\n}\n\n/**\n * Extract expiresIn TTL from a token by subtracting the expiration from the issuance.\n */\nexport function _tokenExpiresIn(token: string): number {\n  const parsedToken = _parseToken(token);\n  _assert(parsedToken, AuthErrorCode.INTERNAL_ERROR);\n  _assert(typeof parsedToken.exp !== 'undefined', AuthErrorCode.INTERNAL_ERROR);\n  _assert(typeof parsedToken.iat !== 'undefined', AuthErrorCode.INTERNAL_ERROR);\n  return Number(parsedToken.exp) - Number(parsedToken.iat);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\n\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\n\nexport async function _logoutIfInvalidated<T>(\n  user: UserInternal,\n  promise: Promise<T>,\n  bypassAuthState = false\n): Promise<T> {\n  if (bypassAuthState) {\n    return promise;\n  }\n  try {\n    return await promise;\n  } catch (e) {\n    if (e instanceof FirebaseError && isUserInvalidated(e)) {\n      if (user.auth.currentUser === user) {\n        await user.auth.signOut();\n      }\n    }\n\n    throw e;\n  }\n}\n\nfunction isUserInvalidated({ code }: FirebaseError): boolean {\n  return (\n    code === `auth/${AuthErrorCode.USER_DISABLED}` ||\n    code === `auth/${AuthErrorCode.TOKEN_EXPIRED}`\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\n\n// Refresh the token five minutes before expiration\nexport const enum Duration {\n  OFFSET = 5 * 1000 * 60,\n  RETRY_BACKOFF_MIN = 30 * 1000,\n  RETRY_BACKOFF_MAX = 16 * 60 * 1000\n}\n\nexport class ProactiveRefresh {\n  private isRunning = false;\n\n  // Node timers and browser timers return fundamentally different types.\n  // We don't actually care what the value is but TS won't accept unknown and\n  // we can't cast properly in both environments.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private timerId: any | null = null;\n  private errorBackoff = Duration.RETRY_BACKOFF_MIN;\n\n  constructor(private readonly user: UserInternal) {}\n\n  _start(): void {\n    if (this.isRunning) {\n      return;\n    }\n\n    this.isRunning = true;\n    this.schedule();\n  }\n\n  _stop(): void {\n    if (!this.isRunning) {\n      return;\n    }\n\n    this.isRunning = false;\n    if (this.timerId !== null) {\n      clearTimeout(this.timerId);\n    }\n  }\n\n  private getInterval(wasError: boolean): number {\n    if (wasError) {\n      const interval = this.errorBackoff;\n      this.errorBackoff = Math.min(\n        this.errorBackoff * 2,\n        Duration.RETRY_BACKOFF_MAX\n      );\n      return interval;\n    } else {\n      // Reset the error backoff\n      this.errorBackoff = Duration.RETRY_BACKOFF_MIN;\n      const expTime = this.user.stsTokenManager.expirationTime ?? 0;\n      const interval = expTime - Date.now() - Duration.OFFSET;\n\n      return Math.max(0, interval);\n    }\n  }\n\n  private schedule(wasError = false): void {\n    if (!this.isRunning) {\n      // Just in case...\n      return;\n    }\n\n    const interval = this.getInterval(wasError);\n    this.timerId = setTimeout(async () => {\n      await this.iteration();\n    }, interval);\n  }\n\n  private async iteration(): Promise<void> {\n    try {\n      await this.user.getIdToken(true);\n    } catch (e) {\n      // Only retry on network errors\n      if (\n        (e as FirebaseError)?.code ===\n        `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`\n      ) {\n        this.schedule(/* wasError */ true);\n      }\n\n      return;\n    }\n    this.schedule();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserMetadata as UserMetadataType } from '../../model/public_types';\n\nimport { utcTimestampToDateString } from '../util/time';\n\nexport class UserMetadata implements UserMetadataType {\n  creationTime?: string;\n  lastSignInTime?: string;\n\n  constructor(\n    private createdAt?: string | number,\n    private lastLoginAt?: string | number\n  ) {\n    this._initializeTime();\n  }\n\n  private _initializeTime(): void {\n    this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);\n    this.creationTime = utcTimestampToDateString(this.createdAt);\n  }\n\n  _copy(metadata: UserMetadata): void {\n    this.createdAt = metadata.createdAt;\n    this.lastLoginAt = metadata.lastLoginAt;\n    this._initializeTime();\n  }\n\n  toJSON(): object {\n    return {\n      createdAt: this.createdAt,\n      lastLoginAt: this.lastLoginAt\n    };\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User, UserInfo } from '../../model/public_types';\n\nimport {\n  getAccountInfo,\n  ProviderUserInfo\n} from '../../api/account_management/account';\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { UserMetadata } from './user_metadata';\nimport { getModularInstance } from '@firebase/util';\n\nexport async function _reloadWithoutSaving(user: UserInternal): Promise<void> {\n  const auth = user.auth;\n  const idToken = await user.getIdToken();\n  const response = await _logoutIfInvalidated(\n    user,\n    getAccountInfo(auth, { idToken })\n  );\n\n  _assert(response?.users.length, auth, AuthErrorCode.INTERNAL_ERROR);\n\n  const coreAccount = response.users[0];\n\n  user._notifyReloadListener(coreAccount);\n\n  const newProviderData = coreAccount.providerUserInfo?.length\n    ? extractProviderData(coreAccount.providerUserInfo)\n    : [];\n\n  const providerData = mergeProviderData(user.providerData, newProviderData);\n\n  // Preserves the non-nonymous status of the stored user, even if no more\n  // credentials (federated or email/password) are linked to the user. If\n  // the user was previously anonymous, then use provider data to update.\n  // On the other hand, if it was not anonymous before, it should never be\n  // considered anonymous now.\n  const oldIsAnonymous = user.isAnonymous;\n  const newIsAnonymous =\n    !(user.email && coreAccount.passwordHash) && !providerData?.length;\n  const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;\n\n  const updates: Partial<UserInternal> = {\n    uid: coreAccount.localId,\n    displayName: coreAccount.displayName || null,\n    photoURL: coreAccount.photoUrl || null,\n    email: coreAccount.email || null,\n    emailVerified: coreAccount.emailVerified || false,\n    phoneNumber: coreAccount.phoneNumber || null,\n    tenantId: coreAccount.tenantId || null,\n    providerData,\n    metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),\n    isAnonymous\n  };\n\n  Object.assign(user, updates);\n}\n\n/**\n * Reloads user account data, if signed in.\n *\n * @param user - The user.\n *\n * @public\n */\nexport async function reload(user: User): Promise<void> {\n  const userInternal: UserInternal = getModularInstance(user) as UserInternal;\n  await _reloadWithoutSaving(userInternal);\n\n  // Even though the current user hasn't changed, update\n  // current user will trigger a persistence update w/ the\n  // new info.\n  await userInternal.auth._persistUserIfCurrent(userInternal);\n  userInternal.auth._notifyListenersIfCurrent(userInternal);\n}\n\nfunction mergeProviderData(\n  original: UserInfo[],\n  newData: UserInfo[]\n): UserInfo[] {\n  const deduped = original.filter(\n    o => !newData.some(n => n.providerId === o.providerId)\n  );\n  return [...deduped, ...newData];\n}\n\nexport function extractProviderData(providers: ProviderUserInfo[]): UserInfo[] {\n  return providers.map(({ providerId, ...provider }) => {\n    return {\n      providerId,\n      uid: provider.rawId || '',\n      displayName: provider.displayName || null,\n      email: provider.email || null,\n      phoneNumber: provider.phoneNumber || null,\n      photoURL: provider.photoUrl || null\n    };\n  });\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable camelcase */\n\nimport { isCloudWorkstation, querystring } from '@firebase/util';\n\nimport {\n  _getFinalTarget,\n  _performFetchWithErrorHandling,\n  _performApiRequest,\n  _addTidIfNecessary,\n  HttpMethod,\n  HttpHeader,\n  Endpoint\n} from '../index';\nimport { FetchProvider } from '../../core/util/fetch_provider';\nimport { Auth } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\n\nexport const enum TokenType {\n  REFRESH_TOKEN = 'REFRESH_TOKEN',\n  ACCESS_TOKEN = 'ACCESS_TOKEN'\n}\n\n/** The server responses with snake_case; we convert to camelCase */\ninterface RequestStsTokenServerResponse {\n  access_token: string;\n  expires_in: string;\n  refresh_token: string;\n}\n\nexport interface RequestStsTokenResponse {\n  accessToken: string;\n  expiresIn: string;\n  refreshToken: string;\n}\n\nexport interface RevokeTokenRequest {\n  providerId: string;\n  tokenType: TokenType;\n  token: string;\n  idToken: string;\n  tenantId?: string;\n}\n\nexport interface RevokeTokenResponse {}\n\nexport async function requestStsToken(\n  auth: Auth,\n  refreshToken: string\n): Promise<RequestStsTokenResponse> {\n  const response =\n    await _performFetchWithErrorHandling<RequestStsTokenServerResponse>(\n      auth,\n      {},\n      async () => {\n        const body = querystring({\n          'grant_type': 'refresh_token',\n          'refresh_token': refreshToken\n        }).slice(1);\n        const { tokenApiHost, apiKey } = auth.config;\n        const url = await _getFinalTarget(\n          auth,\n          tokenApiHost,\n          Endpoint.TOKEN,\n          `key=${apiKey}`\n        );\n\n        const headers = await (auth as AuthInternal)._getAdditionalHeaders();\n        headers[HttpHeader.CONTENT_TYPE] = 'application/x-www-form-urlencoded';\n\n        const options: RequestInit = {\n          method: HttpMethod.POST,\n          headers,\n          body\n        };\n        if (\n          auth.emulatorConfig &&\n          isCloudWorkstation(auth.emulatorConfig.host)\n        ) {\n          options.credentials = 'include';\n        }\n        return FetchProvider.fetch()(url, options);\n      }\n    );\n\n  // The response comes back in snake_case. Convert to camel:\n  return {\n    accessToken: response.access_token,\n    expiresIn: response.expires_in,\n    refreshToken: response.refresh_token\n  };\n}\n\nexport async function revokeToken(\n  auth: Auth,\n  request: RevokeTokenRequest\n): Promise<RevokeTokenResponse> {\n  return _performApiRequest<RevokeTokenRequest, RevokeTokenResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.REVOKE_TOKEN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FinalizeMfaResponse } from '../../api/authentication/mfa';\nimport { requestStsToken } from '../../api/authentication/token';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { PersistedBlob } from '../persistence';\nimport { _assert, debugFail } from '../util/assert';\nimport { _tokenExpiresIn } from './id_token_result';\n\n/**\n * The number of milliseconds before the official expiration time of a token\n * to refresh that token, to provide a buffer for RPCs to complete.\n */\nexport const enum Buffer {\n  TOKEN_REFRESH = 30_000\n}\n\n/**\n * We need to mark this class as internal explicitly to exclude it in the public typings, because\n * it references AuthInternal which has a circular dependency with UserInternal.\n *\n * @internal\n */\nexport class StsTokenManager {\n  refreshToken: string | null = null;\n  accessToken: string | null = null;\n  expirationTime: number | null = null;\n\n  get isExpired(): boolean {\n    return (\n      !this.expirationTime ||\n      Date.now() > this.expirationTime - Buffer.TOKEN_REFRESH\n    );\n  }\n\n  updateFromServerResponse(\n    response: IdTokenResponse | FinalizeMfaResponse\n  ): void {\n    _assert(response.idToken, AuthErrorCode.INTERNAL_ERROR);\n    _assert(\n      typeof response.idToken !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    _assert(\n      typeof response.refreshToken !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const expiresIn =\n      'expiresIn' in response && typeof response.expiresIn !== 'undefined'\n        ? Number(response.expiresIn)\n        : _tokenExpiresIn(response.idToken);\n    this.updateTokensAndExpiration(\n      response.idToken,\n      response.refreshToken,\n      expiresIn\n    );\n  }\n\n  updateFromIdToken(idToken: string): void {\n    _assert(idToken.length !== 0, AuthErrorCode.INTERNAL_ERROR);\n    const expiresIn = _tokenExpiresIn(idToken);\n    this.updateTokensAndExpiration(idToken, null, expiresIn);\n  }\n\n  async getToken(\n    auth: AuthInternal,\n    forceRefresh = false\n  ): Promise<string | null> {\n    if (!forceRefresh && this.accessToken && !this.isExpired) {\n      return this.accessToken;\n    }\n\n    _assert(this.refreshToken, auth, AuthErrorCode.TOKEN_EXPIRED);\n\n    if (this.refreshToken) {\n      await this.refresh(auth, this.refreshToken!);\n      return this.accessToken;\n    }\n\n    return null;\n  }\n\n  clearRefreshToken(): void {\n    this.refreshToken = null;\n  }\n\n  private async refresh(auth: AuthInternal, oldToken: string): Promise<void> {\n    const { accessToken, refreshToken, expiresIn } = await requestStsToken(\n      auth,\n      oldToken\n    );\n    this.updateTokensAndExpiration(\n      accessToken,\n      refreshToken,\n      Number(expiresIn)\n    );\n  }\n\n  private updateTokensAndExpiration(\n    accessToken: string,\n    refreshToken: string | null,\n    expiresInSec: number\n  ): void {\n    this.refreshToken = refreshToken || null;\n    this.accessToken = accessToken || null;\n    this.expirationTime = Date.now() + expiresInSec * 1000;\n  }\n\n  static fromJSON(appName: string, object: PersistedBlob): StsTokenManager {\n    const { refreshToken, accessToken, expirationTime } = object;\n\n    const manager = new StsTokenManager();\n    if (refreshToken) {\n      _assert(typeof refreshToken === 'string', AuthErrorCode.INTERNAL_ERROR, {\n        appName\n      });\n      manager.refreshToken = refreshToken;\n    }\n    if (accessToken) {\n      _assert(typeof accessToken === 'string', AuthErrorCode.INTERNAL_ERROR, {\n        appName\n      });\n      manager.accessToken = accessToken;\n    }\n    if (expirationTime) {\n      _assert(\n        typeof expirationTime === 'number',\n        AuthErrorCode.INTERNAL_ERROR,\n        {\n          appName\n        }\n      );\n      manager.expirationTime = expirationTime;\n    }\n    return manager;\n  }\n\n  toJSON(): object {\n    return {\n      refreshToken: this.refreshToken,\n      accessToken: this.accessToken,\n      expirationTime: this.expirationTime\n    };\n  }\n\n  _assign(stsTokenManager: StsTokenManager): void {\n    this.accessToken = stsTokenManager.accessToken;\n    this.refreshToken = stsTokenManager.refreshToken;\n    this.expirationTime = stsTokenManager.expirationTime;\n  }\n\n  _clone(): StsTokenManager {\n    return Object.assign(new StsTokenManager(), this.toJSON());\n  }\n\n  _performRefresh(): never {\n    return debugFail('not implemented');\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IdTokenResult, UserInfo } from '../../model/public_types';\nimport { NextFn } from '@firebase/util';\nimport {\n  APIUserInfo,\n  GetAccountInfoResponse,\n  deleteAccount\n} from '../../api/account_management/account';\nimport { FinalizeMfaResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport {\n  MutableUserInfo,\n  UserInternal,\n  UserParameters\n} from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { PersistedBlob } from '../persistence';\nimport {\n  _assert,\n  _serverAppCurrentUserOperationNotSupportedError\n} from '../util/assert';\nimport { getIdTokenResult } from './id_token_result';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { ProactiveRefresh } from './proactive_refresh';\nimport { extractProviderData, _reloadWithoutSaving, reload } from './reload';\nimport { StsTokenManager } from './token_manager';\nimport { UserMetadata } from './user_metadata';\nimport { ProviderId } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\n\nfunction assertStringOrUndefined(\n  assertion: unknown,\n  appName: string\n): asserts assertion is string | undefined {\n  _assert(\n    typeof assertion === 'string' || typeof assertion === 'undefined',\n    AuthErrorCode.INTERNAL_ERROR,\n    { appName }\n  );\n}\n\nexport class UserImpl implements UserInternal {\n  // For the user object, provider is always Firebase.\n  readonly providerId = ProviderId.FIREBASE;\n  stsTokenManager: StsTokenManager;\n  // Last known accessToken so we know when it changes\n  private accessToken: string | null;\n\n  uid: string;\n  auth: AuthInternal;\n  emailVerified: boolean;\n  isAnonymous: boolean;\n  tenantId: string | null;\n  readonly metadata: UserMetadata;\n  providerData: MutableUserInfo[];\n\n  // Optional fields from UserInfo\n  displayName: string | null;\n  email: string | null;\n  phoneNumber: string | null;\n  photoURL: string | null;\n\n  _redirectEventId?: string;\n  private readonly proactiveRefresh = new ProactiveRefresh(this);\n\n  constructor({ uid, auth, stsTokenManager, ...opt }: UserParameters) {\n    this.uid = uid;\n    this.auth = auth;\n    this.stsTokenManager = stsTokenManager;\n    this.accessToken = stsTokenManager.accessToken;\n    this.displayName = opt.displayName || null;\n    this.email = opt.email || null;\n    this.emailVerified = opt.emailVerified || false;\n    this.phoneNumber = opt.phoneNumber || null;\n    this.photoURL = opt.photoURL || null;\n    this.isAnonymous = opt.isAnonymous || false;\n    this.tenantId = opt.tenantId || null;\n    this.providerData = opt.providerData ? [...opt.providerData] : [];\n    this.metadata = new UserMetadata(\n      opt.createdAt || undefined,\n      opt.lastLoginAt || undefined\n    );\n  }\n\n  async getIdToken(forceRefresh?: boolean): Promise<string> {\n    const accessToken = await _logoutIfInvalidated(\n      this,\n      this.stsTokenManager.getToken(this.auth, forceRefresh)\n    );\n    _assert(accessToken, this.auth, AuthErrorCode.INTERNAL_ERROR);\n\n    if (this.accessToken !== accessToken) {\n      this.accessToken = accessToken;\n      await this.auth._persistUserIfCurrent(this);\n      this.auth._notifyListenersIfCurrent(this);\n    }\n\n    return accessToken;\n  }\n\n  getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult> {\n    return getIdTokenResult(this, forceRefresh);\n  }\n\n  reload(): Promise<void> {\n    return reload(this);\n  }\n\n  private reloadUserInfo: APIUserInfo | null = null;\n  private reloadListener: NextFn<APIUserInfo> | null = null;\n\n  _assign(user: UserInternal): void {\n    if (this === user) {\n      return;\n    }\n    _assert(this.uid === user.uid, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.displayName = user.displayName;\n    this.photoURL = user.photoURL;\n    this.email = user.email;\n    this.emailVerified = user.emailVerified;\n    this.phoneNumber = user.phoneNumber;\n    this.isAnonymous = user.isAnonymous;\n    this.tenantId = user.tenantId;\n    this.providerData = user.providerData.map(userInfo => ({ ...userInfo }));\n    this.metadata._copy(user.metadata);\n    this.stsTokenManager._assign(user.stsTokenManager);\n  }\n\n  _clone(auth: AuthInternal): UserInternal {\n    const newUser = new UserImpl({\n      ...this,\n      auth,\n      stsTokenManager: this.stsTokenManager._clone()\n    });\n    newUser.metadata._copy(this.metadata);\n    return newUser;\n  }\n\n  _onReload(callback: NextFn<APIUserInfo>): void {\n    // There should only ever be one listener, and that is a single instance of MultiFactorUser\n    _assert(!this.reloadListener, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.reloadListener = callback;\n    if (this.reloadUserInfo) {\n      this._notifyReloadListener(this.reloadUserInfo);\n      this.reloadUserInfo = null;\n    }\n  }\n\n  _notifyReloadListener(userInfo: APIUserInfo): void {\n    if (this.reloadListener) {\n      this.reloadListener(userInfo);\n    } else {\n      // If no listener is subscribed yet, save the result so it's available when they do subscribe\n      this.reloadUserInfo = userInfo;\n    }\n  }\n\n  _startProactiveRefresh(): void {\n    this.proactiveRefresh._start();\n  }\n\n  _stopProactiveRefresh(): void {\n    this.proactiveRefresh._stop();\n  }\n\n  async _updateTokensIfNecessary(\n    response: IdTokenResponse | FinalizeMfaResponse,\n    reload = false\n  ): Promise<void> {\n    let tokensRefreshed = false;\n    if (\n      response.idToken &&\n      response.idToken !== this.stsTokenManager.accessToken\n    ) {\n      this.stsTokenManager.updateFromServerResponse(response);\n      tokensRefreshed = true;\n    }\n\n    if (reload) {\n      await _reloadWithoutSaving(this);\n    }\n\n    await this.auth._persistUserIfCurrent(this);\n    if (tokensRefreshed) {\n      this.auth._notifyListenersIfCurrent(this);\n    }\n  }\n\n  async delete(): Promise<void> {\n    if (_isFirebaseServerApp(this.auth.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this.auth)\n      );\n    }\n    const idToken = await this.getIdToken();\n    await _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken }));\n    this.stsTokenManager.clearRefreshToken();\n\n    // TODO: Determine if cancellable-promises are necessary to use in this class so that delete()\n    //       cancels pending actions...\n\n    return this.auth.signOut();\n  }\n\n  toJSON(): PersistedBlob {\n    return {\n      uid: this.uid,\n      email: this.email || undefined,\n      emailVerified: this.emailVerified,\n      displayName: this.displayName || undefined,\n      isAnonymous: this.isAnonymous,\n      photoURL: this.photoURL || undefined,\n      phoneNumber: this.phoneNumber || undefined,\n      tenantId: this.tenantId || undefined,\n      providerData: this.providerData.map(userInfo => ({ ...userInfo })),\n      stsTokenManager: this.stsTokenManager.toJSON(),\n      // Redirect event ID must be maintained in case there is a pending\n      // redirect event.\n      _redirectEventId: this._redirectEventId,\n      ...this.metadata.toJSON(),\n\n      // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):\n      apiKey: this.auth.config.apiKey,\n      appName: this.auth.name\n      // Missing authDomain will be tolerated by the legacy SDK.\n      // stsTokenManager.apiKey isn't actually required (despite the legacy SDK persisting it).\n    };\n  }\n\n  get refreshToken(): string {\n    return this.stsTokenManager.refreshToken || '';\n  }\n\n  static _fromJSON(auth: AuthInternal, object: PersistedBlob): UserInternal {\n    const displayName = object.displayName ?? undefined;\n    const email = object.email ?? undefined;\n    const phoneNumber = object.phoneNumber ?? undefined;\n    const photoURL = object.photoURL ?? undefined;\n    const tenantId = object.tenantId ?? undefined;\n    const _redirectEventId = object._redirectEventId ?? undefined;\n    const createdAt = object.createdAt ?? undefined;\n    const lastLoginAt = object.lastLoginAt ?? undefined;\n    const {\n      uid,\n      emailVerified,\n      isAnonymous,\n      providerData,\n      stsTokenManager: plainObjectTokenManager\n    } = object;\n\n    _assert(uid && plainObjectTokenManager, auth, AuthErrorCode.INTERNAL_ERROR);\n\n    const stsTokenManager = StsTokenManager.fromJSON(\n      this.name,\n      plainObjectTokenManager as PersistedBlob\n    );\n\n    _assert(typeof uid === 'string', auth, AuthErrorCode.INTERNAL_ERROR);\n    assertStringOrUndefined(displayName, auth.name);\n    assertStringOrUndefined(email, auth.name);\n    _assert(\n      typeof emailVerified === 'boolean',\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    _assert(\n      typeof isAnonymous === 'boolean',\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    assertStringOrUndefined(phoneNumber, auth.name);\n    assertStringOrUndefined(photoURL, auth.name);\n    assertStringOrUndefined(tenantId, auth.name);\n    assertStringOrUndefined(_redirectEventId, auth.name);\n    assertStringOrUndefined(createdAt, auth.name);\n    assertStringOrUndefined(lastLoginAt, auth.name);\n    const user = new UserImpl({\n      uid,\n      auth,\n      email,\n      emailVerified,\n      displayName,\n      isAnonymous,\n      photoURL,\n      phoneNumber,\n      tenantId,\n      stsTokenManager,\n      createdAt,\n      lastLoginAt\n    });\n\n    if (providerData && Array.isArray(providerData)) {\n      user.providerData = providerData.map(userInfo => ({ ...userInfo }));\n    }\n\n    if (_redirectEventId) {\n      user._redirectEventId = _redirectEventId;\n    }\n\n    return user;\n  }\n\n  /**\n   * Initialize a User from an idToken server response\n   * @param auth\n   * @param idTokenResponse\n   */\n  static async _fromIdTokenResponse(\n    auth: AuthInternal,\n    idTokenResponse: IdTokenResponse,\n    isAnonymous: boolean = false\n  ): Promise<UserInternal> {\n    const stsTokenManager = new StsTokenManager();\n    stsTokenManager.updateFromServerResponse(idTokenResponse);\n\n    // Initialize the Firebase Auth user.\n    const user = new UserImpl({\n      uid: idTokenResponse.localId,\n      auth,\n      stsTokenManager,\n      isAnonymous\n    });\n\n    // Updates the user info and data and resolves with a user instance.\n    await _reloadWithoutSaving(user);\n    return user;\n  }\n\n  /**\n   * Initialize a User from an idToken server response\n   * @param auth\n   * @param idTokenResponse\n   */\n  static async _fromGetAccountInfoResponse(\n    auth: AuthInternal,\n    response: GetAccountInfoResponse,\n    idToken: string\n  ): Promise<UserInternal> {\n    const coreAccount = response.users[0];\n    _assert(coreAccount.localId !== undefined, AuthErrorCode.INTERNAL_ERROR);\n\n    const providerData: UserInfo[] =\n      coreAccount.providerUserInfo !== undefined\n        ? extractProviderData(coreAccount.providerUserInfo)\n        : [];\n\n    const isAnonymous =\n      !(coreAccount.email && coreAccount.passwordHash) && !providerData?.length;\n\n    const stsTokenManager = new StsTokenManager();\n    stsTokenManager.updateFromIdToken(idToken);\n\n    // Initialize the Firebase Auth user.\n    const user = new UserImpl({\n      uid: coreAccount.localId,\n      auth,\n      stsTokenManager,\n      isAnonymous\n    });\n\n    // update the user with data from the GetAccountInfo response.\n    const updates: Partial<UserInternal> = {\n      uid: coreAccount.localId,\n      displayName: coreAccount.displayName || null,\n      photoURL: coreAccount.photoUrl || null,\n      email: coreAccount.email || null,\n      emailVerified: coreAccount.emailVerified || false,\n      phoneNumber: coreAccount.phoneNumber || null,\n      tenantId: coreAccount.tenantId || null,\n      providerData,\n      metadata: new UserMetadata(\n        coreAccount.createdAt,\n        coreAccount.lastLoginAt\n      ),\n      isAnonymous:\n        !(coreAccount.email && coreAccount.passwordHash) &&\n        !providerData?.length\n    };\n\n    Object.assign(user, updates);\n    return user;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debugAssert } from './assert';\n\n/**\n * Our API has a lot of one-off constants that are used to do things.\n * Unfortunately we can't export these as classes instantiated directly since\n * the constructor may side effect and therefore can't be proven to be safely\n * culled. Instead, we export these classes themselves as a lowerCamelCase\n * constant, and instantiate them under the hood.\n */\nexport interface SingletonInstantiator<T> {\n  new (): T;\n}\n\nconst instanceCache: Map<unknown, unknown> = new Map();\n\nexport function _getInstance<T>(cls: unknown): T {\n  debugAssert(cls instanceof Function, 'Expected a class definition');\n  let instance = instanceCache.get(cls) as T | undefined;\n\n  if (instance) {\n    debugAssert(\n      instance instanceof cls,\n      'Instance stored in cache mismatched with class'\n    );\n    return instance;\n  }\n\n  instance = new (cls as SingletonInstantiator<T>)();\n  instanceCache.set(cls, instance);\n  return instance;\n}\n\nexport function _clearInstanceMap(): void {\n  instanceCache.clear();\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Persistence } from '../../model/public_types';\n\nimport {\n  PersistenceInternal,\n  PersistenceType,\n  PersistenceValue,\n  StorageEventListener\n} from '../persistence';\n\nexport class InMemoryPersistence implements PersistenceInternal {\n  static type: 'NONE' = 'NONE';\n  readonly type = PersistenceType.NONE;\n  storage: Record<string, PersistenceValue> = {};\n\n  async _isAvailable(): Promise<boolean> {\n    return true;\n  }\n\n  async _set(key: string, value: PersistenceValue): Promise<void> {\n    this.storage[key] = value;\n  }\n\n  async _get<T extends PersistenceValue>(key: string): Promise<T | null> {\n    const value = this.storage[key];\n    return value === undefined ? null : (value as T);\n  }\n\n  async _remove(key: string): Promise<void> {\n    delete this.storage[key];\n  }\n\n  _addListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers\n    return;\n  }\n\n  _removeListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers\n    return;\n  }\n}\n\n/**\n * An implementation of {@link Persistence} of type 'NONE'.\n *\n * @public\n */\nexport const inMemoryPersistence: Persistence = InMemoryPersistence;\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getAccountInfo } from '../../api/account_management/account';\nimport { ApiKey, AppName, AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { PersistedBlob, PersistenceInternal } from '../persistence';\nimport { UserImpl } from '../user/user_impl';\nimport { _getInstance } from '../util/instantiator';\nimport { inMemoryPersistence } from './in_memory';\n\nexport const enum KeyName {\n  AUTH_USER = 'authUser',\n  AUTH_EVENT = 'authEvent',\n  REDIRECT_USER = 'redirectUser',\n  PERSISTENCE_USER = 'persistence'\n}\nexport const enum Namespace {\n  PERSISTENCE = 'firebase'\n}\n\nexport function _persistenceKeyName(\n  key: string,\n  apiKey: ApiKey,\n  appName: AppName\n): string {\n  return `${Namespace.PERSISTENCE}:${key}:${apiKey}:${appName}`;\n}\n\nexport class PersistenceUserManager {\n  private readonly fullUserKey: string;\n  private readonly fullPersistenceKey: string;\n  private readonly boundEventHandler: () => void;\n\n  private constructor(\n    public persistence: PersistenceInternal,\n    private readonly auth: AuthInternal,\n    private readonly userKey: string\n  ) {\n    const { config, name } = this.auth;\n    this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name);\n    this.fullPersistenceKey = _persistenceKeyName(\n      KeyName.PERSISTENCE_USER,\n      config.apiKey,\n      name\n    );\n    this.boundEventHandler = auth._onStorageEvent.bind(auth);\n    this.persistence._addListener(this.fullUserKey, this.boundEventHandler);\n  }\n\n  setCurrentUser(user: UserInternal): Promise<void> {\n    return this.persistence._set(this.fullUserKey, user.toJSON());\n  }\n\n  async getCurrentUser(): Promise<UserInternal | null> {\n    const blob = await this.persistence._get<PersistedBlob | string>(\n      this.fullUserKey\n    );\n    if (!blob) {\n      return null;\n    }\n    if (typeof blob === 'string') {\n      const response = await getAccountInfo(this.auth, { idToken: blob }).catch(\n        () => undefined\n      );\n      if (!response) {\n        return null;\n      }\n      return UserImpl._fromGetAccountInfoResponse(this.auth, response, blob);\n    }\n    return UserImpl._fromJSON(this.auth, blob);\n  }\n\n  removeCurrentUser(): Promise<void> {\n    return this.persistence._remove(this.fullUserKey);\n  }\n\n  savePersistenceForRedirect(): Promise<void> {\n    return this.persistence._set(\n      this.fullPersistenceKey,\n      this.persistence.type\n    );\n  }\n\n  async setPersistence(newPersistence: PersistenceInternal): Promise<void> {\n    if (this.persistence === newPersistence) {\n      return;\n    }\n\n    const currentUser = await this.getCurrentUser();\n    await this.removeCurrentUser();\n\n    this.persistence = newPersistence;\n\n    if (currentUser) {\n      return this.setCurrentUser(currentUser);\n    }\n  }\n\n  delete(): void {\n    this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);\n  }\n\n  static async create(\n    auth: AuthInternal,\n    persistenceHierarchy: PersistenceInternal[],\n    userKey = KeyName.AUTH_USER\n  ): Promise<PersistenceUserManager> {\n    if (!persistenceHierarchy.length) {\n      return new PersistenceUserManager(\n        _getInstance(inMemoryPersistence),\n        auth,\n        userKey\n      );\n    }\n\n    // Eliminate any persistences that are not available\n    const availablePersistences = (\n      await Promise.all(\n        persistenceHierarchy.map(async persistence => {\n          if (await persistence._isAvailable()) {\n            return persistence;\n          }\n          return undefined;\n        })\n      )\n    ).filter(persistence => persistence) as PersistenceInternal[];\n\n    // Fall back to the first persistence listed, or in memory if none available\n    let selectedPersistence =\n      availablePersistences[0] ||\n      _getInstance<PersistenceInternal>(inMemoryPersistence);\n\n    const key = _persistenceKeyName(userKey, auth.config.apiKey, auth.name);\n\n    // Pull out the existing user, setting the chosen persistence to that\n    // persistence if the user exists.\n    let userToMigrate: UserInternal | null = null;\n    // Note, here we check for a user in _all_ persistences, not just the\n    // ones deemed available. If we can migrate a user out of a broken\n    // persistence, we will (but only if that persistence supports migration).\n    for (const persistence of persistenceHierarchy) {\n      try {\n        const blob = await persistence._get<PersistedBlob | string>(key);\n        if (blob) {\n          let user: UserInternal;\n          if (typeof blob === 'string') {\n            const response = await getAccountInfo(auth, {\n              idToken: blob\n            }).catch(() => undefined);\n            if (!response) {\n              break;\n            }\n            user = await UserImpl._fromGetAccountInfoResponse(\n              auth,\n              response,\n              blob\n            );\n          } else {\n            user = UserImpl._fromJSON(auth, blob); // throws for unparsable blob (wrong format)\n          }\n          if (persistence !== selectedPersistence) {\n            userToMigrate = user;\n          }\n          selectedPersistence = persistence;\n          break;\n        }\n      } catch {}\n    }\n\n    // If we find the user in a persistence that does support migration, use\n    // that migration path (of only persistences that support migration)\n    const migrationHierarchy = availablePersistences.filter(\n      p => p._shouldAllowMigration\n    );\n\n    // If the persistence does _not_ allow migration, just finish off here\n    if (\n      !selectedPersistence._shouldAllowMigration ||\n      !migrationHierarchy.length\n    ) {\n      return new PersistenceUserManager(selectedPersistence, auth, userKey);\n    }\n\n    selectedPersistence = migrationHierarchy[0];\n    if (userToMigrate) {\n      // This normally shouldn't throw since chosenPersistence.isAvailable() is true, but if it does\n      // we'll just let it bubble to surface the error.\n      await selectedPersistence._set(key, userToMigrate.toJSON());\n    }\n\n    // Attempt to clear the key in other persistences but ignore errors. This helps prevent issues\n    // such as users getting stuck with a previous account after signing out and refreshing the tab.\n    await Promise.all(\n      persistenceHierarchy.map(async persistence => {\n        if (persistence !== selectedPersistence) {\n          try {\n            await persistence._remove(key);\n          } catch {}\n        }\n      })\n    );\n    return new PersistenceUserManager(selectedPersistence, auth, userKey);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isIE, getUA } from '@firebase/util';\n\ninterface NavigatorStandalone extends Navigator {\n  standalone?: unknown;\n}\n\ninterface Document {\n  documentMode?: number;\n}\n\n/**\n * Enums for Browser name.\n */\nexport const enum BrowserName {\n  ANDROID = 'Android',\n  BLACKBERRY = 'Blackberry',\n  EDGE = 'Edge',\n  FIREFOX = 'Firefox',\n  IE = 'IE',\n  IEMOBILE = 'IEMobile',\n  OPERA = 'Opera',\n  OTHER = 'Other',\n  CHROME = 'Chrome',\n  SAFARI = 'Safari',\n  SILK = 'Silk',\n  WEBOS = 'Webos'\n}\n\n/**\n * Determine the browser for the purposes of reporting usage to the API\n */\nexport function _getBrowserName(userAgent: string): BrowserName | string {\n  const ua = userAgent.toLowerCase();\n  if (ua.includes('opera/') || ua.includes('opr/') || ua.includes('opios/')) {\n    return BrowserName.OPERA;\n  } else if (_isIEMobile(ua)) {\n    // Windows phone IEMobile browser.\n    return BrowserName.IEMOBILE;\n  } else if (ua.includes('msie') || ua.includes('trident/')) {\n    return BrowserName.IE;\n  } else if (ua.includes('edge/')) {\n    return BrowserName.EDGE;\n  } else if (_isFirefox(ua)) {\n    return BrowserName.FIREFOX;\n  } else if (ua.includes('silk/')) {\n    return BrowserName.SILK;\n  } else if (_isBlackBerry(ua)) {\n    // Blackberry browser.\n    return BrowserName.BLACKBERRY;\n  } else if (_isWebOS(ua)) {\n    // WebOS default browser.\n    return BrowserName.WEBOS;\n  } else if (_isSafari(ua)) {\n    return BrowserName.SAFARI;\n  } else if (\n    (ua.includes('chrome/') || _isChromeIOS(ua)) &&\n    !ua.includes('edge/')\n  ) {\n    return BrowserName.CHROME;\n  } else if (_isAndroid(ua)) {\n    // Android stock browser.\n    return BrowserName.ANDROID;\n  } else {\n    // Most modern browsers have name/version at end of user agent string.\n    const re = /([a-zA-Z\\d\\.]+)\\/[a-zA-Z\\d\\.]*$/;\n    const matches = userAgent.match(re);\n    if (matches?.length === 2) {\n      return matches[1];\n    }\n  }\n  return BrowserName.OTHER;\n}\n\nexport function _isFirefox(ua = getUA()): boolean {\n  return /firefox\\//i.test(ua);\n}\n\nexport function _isSafari(userAgent = getUA()): boolean {\n  const ua = userAgent.toLowerCase();\n  return (\n    ua.includes('safari/') &&\n    !ua.includes('chrome/') &&\n    !ua.includes('crios/') &&\n    !ua.includes('android')\n  );\n}\n\nexport function _isChromeIOS(ua = getUA()): boolean {\n  return /crios\\//i.test(ua);\n}\n\nexport function _isIEMobile(ua = getUA()): boolean {\n  return /iemobile/i.test(ua);\n}\n\nexport function _isAndroid(ua = getUA()): boolean {\n  return /android/i.test(ua);\n}\n\nexport function _isBlackBerry(ua = getUA()): boolean {\n  return /blackberry/i.test(ua);\n}\n\nexport function _isWebOS(ua = getUA()): boolean {\n  return /webos/i.test(ua);\n}\n\nexport function _isIOS(ua = getUA()): boolean {\n  return (\n    /iphone|ipad|ipod/i.test(ua) ||\n    (/macintosh/i.test(ua) && /mobile/i.test(ua))\n  );\n}\n\nexport function _isIOS7Or8(ua = getUA()): boolean {\n  return (\n    /(iPad|iPhone|iPod).*OS 7_\\d/i.test(ua) ||\n    /(iPad|iPhone|iPod).*OS 8_\\d/i.test(ua)\n  );\n}\n\nexport function _isIOSStandalone(ua = getUA()): boolean {\n  return _isIOS(ua) && !!(window.navigator as NavigatorStandalone)?.standalone;\n}\n\nexport function _isIE10(): boolean {\n  return isIE() && (document as Document).documentMode === 10;\n}\n\nexport function _isMobileBrowser(ua: string = getUA()): boolean {\n  // TODO: implement getBrowserName equivalent for OS.\n  return (\n    _isIOS(ua) ||\n    _isAndroid(ua) ||\n    _isWebOS(ua) ||\n    _isBlackBerry(ua) ||\n    /windows phone/i.test(ua) ||\n    _isIEMobile(ua)\n  );\n}\n\nexport function _isIframe(): boolean {\n  try {\n    // Check that the current window is not the top window.\n    // If so, return true.\n    return !!(window && window !== window.top);\n  } catch (e) {\n    return false;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SDK_VERSION } from '@firebase/app';\nimport { _getBrowserName } from './browser';\nimport { getUA } from '@firebase/util';\n\nexport const enum ClientImplementation {\n  CORE = 'JsCore'\n}\n\n/**\n * @internal\n */\nexport const enum ClientPlatform {\n  BROWSER = 'Browser',\n  NODE = 'Node',\n  REACT_NATIVE = 'ReactNative',\n  CORDOVA = 'Cordova',\n  WORKER = 'Worker',\n  WEB_EXTENSION = 'WebExtension'\n}\n\n/*\n * Determine the SDK version string\n */\nexport function _getClientVersion(\n  clientPlatform: ClientPlatform,\n  frameworks: readonly string[] = []\n): string {\n  let reportedPlatform: string;\n  switch (clientPlatform) {\n    case ClientPlatform.BROWSER:\n      // In a browser environment, report the browser name.\n      reportedPlatform = _getBrowserName(getUA());\n      break;\n    case ClientPlatform.WORKER:\n      // Technically a worker runs from a browser but we need to differentiate a\n      // worker from a browser.\n      // For example: Chrome-Worker/JsCore/4.9.1/FirebaseCore-web.\n      reportedPlatform = `${_getBrowserName(getUA())}-${clientPlatform}`;\n      break;\n    default:\n      reportedPlatform = clientPlatform;\n  }\n  const reportedFrameworks = frameworks.length\n    ? frameworks.join(',')\n    : 'FirebaseCore-web'; /* default value if no other framework is used */\n  return `${reportedPlatform}/${ClientImplementation.CORE}/${SDK_VERSION}/${reportedFrameworks}`;\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthInternal } from '../../model/auth';\nimport { Unsubscribe, User } from '../../model/public_types';\nimport { AuthErrorCode } from '../errors';\n\ninterface MiddlewareEntry {\n  (user: User | null): Promise<void>;\n  onAbort?: () => void;\n}\n\nexport class AuthMiddlewareQueue {\n  private readonly queue: MiddlewareEntry[] = [];\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  pushCallback(\n    callback: (user: User | null) => void | Promise<void>,\n    onAbort?: () => void\n  ): Unsubscribe {\n    // The callback could be sync or async. Wrap it into a\n    // function that is always async.\n    const wrappedCallback: MiddlewareEntry = (\n      user: User | null\n    ): Promise<void> =>\n      new Promise((resolve, reject) => {\n        try {\n          const result = callback(user);\n          // Either resolve with existing promise or wrap a non-promise\n          // return value into a promise.\n          resolve(result);\n        } catch (e) {\n          // Sync callback throws.\n          reject(e);\n        }\n      });\n    // Attach the onAbort if present\n    wrappedCallback.onAbort = onAbort;\n    this.queue.push(wrappedCallback);\n\n    const index = this.queue.length - 1;\n    return () => {\n      // Unsubscribe. Replace with no-op. Do not remove from array, or it will disturb\n      // indexing of other elements.\n      this.queue[index] = () => Promise.resolve();\n    };\n  }\n\n  async runMiddleware(nextUser: User | null): Promise<void> {\n    if (this.auth.currentUser === nextUser) {\n      return;\n    }\n\n    // While running the middleware, build a temporary stack of onAbort\n    // callbacks to call if one middleware callback rejects.\n\n    const onAbortStack: Array<() => void> = [];\n    try {\n      for (const beforeStateCallback of this.queue) {\n        await beforeStateCallback(nextUser);\n\n        // Only push the onAbort if the callback succeeds\n        if (beforeStateCallback.onAbort) {\n          onAbortStack.push(beforeStateCallback.onAbort);\n        }\n      }\n    } catch (e) {\n      // Run all onAbort, with separate try/catch to ignore any errors and\n      // continue\n      onAbortStack.reverse();\n      for (const onAbort of onAbortStack) {\n        try {\n          onAbort();\n        } catch (_) {\n          /* swallow error */\n        }\n      }\n\n      throw this.auth._errorFactory.create(AuthErrorCode.LOGIN_BLOCKED, {\n        originalMessage: (e as Error)?.message\n      });\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performApiRequest,\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\n/**\n * Request object for fetching the password policy.\n */\nexport interface GetPasswordPolicyRequest {\n  tenantId?: string;\n}\n\n/**\n * Response object for fetching the password policy.\n */\nexport interface GetPasswordPolicyResponse {\n  customStrengthOptions: {\n    minPasswordLength?: number;\n    maxPasswordLength?: number;\n    containsLowercaseCharacter?: boolean;\n    containsUppercaseCharacter?: boolean;\n    containsNumericCharacter?: boolean;\n    containsNonAlphanumericCharacter?: boolean;\n  };\n  allowedNonAlphanumericCharacters?: string[];\n  enforcementState: string;\n  forceUpgradeOnSignin?: boolean;\n  schemaVersion: number;\n}\n\n/**\n * Fetches the password policy for the currently set tenant or the project if no tenant is set.\n *\n * @param auth Auth object.\n * @param request Password policy request.\n * @returns Password policy response.\n */\nexport async function _getPasswordPolicy(\n  auth: Auth,\n  request: GetPasswordPolicyRequest = {}\n): Promise<GetPasswordPolicyResponse> {\n  return _performApiRequest<\n    GetPasswordPolicyRequest,\n    GetPasswordPolicyResponse\n  >(\n    auth,\n    HttpMethod.GET,\n    Endpoint.GET_PASSWORD_POLICY,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { GetPasswordPolicyResponse } from '../../api/password_policy/get_password_policy';\nimport {\n  PasswordPolicyCustomStrengthOptions,\n  PasswordPolicyInternal,\n  PasswordValidationStatusInternal\n} from '../../model/password_policy';\nimport { PasswordValidationStatus } from '../../model/public_types';\n\n// Minimum min password length enforced by the backend, even if no minimum length is set.\nconst MINIMUM_MIN_PASSWORD_LENGTH = 6;\n\n/**\n * Stores password policy requirements and provides password validation against the policy.\n *\n * @internal\n */\nexport class PasswordPolicyImpl implements PasswordPolicyInternal {\n  readonly customStrengthOptions: PasswordPolicyCustomStrengthOptions;\n  readonly allowedNonAlphanumericCharacters: string;\n  readonly enforcementState: string;\n  readonly forceUpgradeOnSignin: boolean;\n  readonly schemaVersion: number;\n\n  constructor(response: GetPasswordPolicyResponse) {\n    // Only include custom strength options defined in the response.\n    const responseOptions = response.customStrengthOptions;\n    this.customStrengthOptions = {};\n    // TODO: Remove once the backend is updated to include the minimum min password length instead of undefined when there is no minimum length set.\n    this.customStrengthOptions.minPasswordLength =\n      responseOptions.minPasswordLength ?? MINIMUM_MIN_PASSWORD_LENGTH;\n    if (responseOptions.maxPasswordLength) {\n      this.customStrengthOptions.maxPasswordLength =\n        responseOptions.maxPasswordLength;\n    }\n    if (responseOptions.containsLowercaseCharacter !== undefined) {\n      this.customStrengthOptions.containsLowercaseLetter =\n        responseOptions.containsLowercaseCharacter;\n    }\n    if (responseOptions.containsUppercaseCharacter !== undefined) {\n      this.customStrengthOptions.containsUppercaseLetter =\n        responseOptions.containsUppercaseCharacter;\n    }\n    if (responseOptions.containsNumericCharacter !== undefined) {\n      this.customStrengthOptions.containsNumericCharacter =\n        responseOptions.containsNumericCharacter;\n    }\n    if (responseOptions.containsNonAlphanumericCharacter !== undefined) {\n      this.customStrengthOptions.containsNonAlphanumericCharacter =\n        responseOptions.containsNonAlphanumericCharacter;\n    }\n\n    this.enforcementState = response.enforcementState;\n    if (this.enforcementState === 'ENFORCEMENT_STATE_UNSPECIFIED') {\n      this.enforcementState = 'OFF';\n    }\n\n    // Use an empty string if no non-alphanumeric characters are specified in the response.\n    this.allowedNonAlphanumericCharacters =\n      response.allowedNonAlphanumericCharacters?.join('') ?? '';\n\n    this.forceUpgradeOnSignin = response.forceUpgradeOnSignin ?? false;\n    this.schemaVersion = response.schemaVersion;\n  }\n\n  validatePassword(password: string): PasswordValidationStatus {\n    const status: PasswordValidationStatusInternal = {\n      isValid: true,\n      passwordPolicy: this\n    };\n\n    // Check the password length and character options.\n    this.validatePasswordLengthOptions(password, status);\n    this.validatePasswordCharacterOptions(password, status);\n\n    // Combine the status into single isValid property.\n    status.isValid &&= status.meetsMinPasswordLength ?? true;\n    status.isValid &&= status.meetsMaxPasswordLength ?? true;\n    status.isValid &&= status.containsLowercaseLetter ?? true;\n    status.isValid &&= status.containsUppercaseLetter ?? true;\n    status.isValid &&= status.containsNumericCharacter ?? true;\n    status.isValid &&= status.containsNonAlphanumericCharacter ?? true;\n\n    return status;\n  }\n\n  /**\n   * Validates that the password meets the length options for the policy.\n   *\n   * @param password Password to validate.\n   * @param status Validation status.\n   */\n  private validatePasswordLengthOptions(\n    password: string,\n    status: PasswordValidationStatusInternal\n  ): void {\n    const minPasswordLength = this.customStrengthOptions.minPasswordLength;\n    const maxPasswordLength = this.customStrengthOptions.maxPasswordLength;\n    if (minPasswordLength) {\n      status.meetsMinPasswordLength = password.length >= minPasswordLength;\n    }\n    if (maxPasswordLength) {\n      status.meetsMaxPasswordLength = password.length <= maxPasswordLength;\n    }\n  }\n\n  /**\n   * Validates that the password meets the character options for the policy.\n   *\n   * @param password Password to validate.\n   * @param status Validation status.\n   */\n  private validatePasswordCharacterOptions(\n    password: string,\n    status: PasswordValidationStatusInternal\n  ): void {\n    // Assign statuses for requirements even if the password is an empty string.\n    this.updatePasswordCharacterOptionsStatuses(\n      status,\n      /* containsLowercaseCharacter= */ false,\n      /* containsUppercaseCharacter= */ false,\n      /* containsNumericCharacter= */ false,\n      /* containsNonAlphanumericCharacter= */ false\n    );\n\n    let passwordChar;\n    for (let i = 0; i < password.length; i++) {\n      passwordChar = password.charAt(i);\n      this.updatePasswordCharacterOptionsStatuses(\n        status,\n        /* containsLowercaseCharacter= */ passwordChar >= 'a' &&\n          passwordChar <= 'z',\n        /* containsUppercaseCharacter= */ passwordChar >= 'A' &&\n          passwordChar <= 'Z',\n        /* containsNumericCharacter= */ passwordChar >= '0' &&\n          passwordChar <= '9',\n        /* containsNonAlphanumericCharacter= */ this.allowedNonAlphanumericCharacters.includes(\n          passwordChar\n        )\n      );\n    }\n  }\n\n  /**\n   * Updates the running validation status with the statuses for the character options.\n   * Expected to be called each time a character is processed to update each option status\n   * based on the current character.\n   *\n   * @param status Validation status.\n   * @param containsLowercaseCharacter Whether the character is a lowercase letter.\n   * @param containsUppercaseCharacter Whether the character is an uppercase letter.\n   * @param containsNumericCharacter Whether the character is a numeric character.\n   * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.\n   */\n  private updatePasswordCharacterOptionsStatuses(\n    status: PasswordValidationStatusInternal,\n    containsLowercaseCharacter: boolean,\n    containsUppercaseCharacter: boolean,\n    containsNumericCharacter: boolean,\n    containsNonAlphanumericCharacter: boolean\n  ): void {\n    if (this.customStrengthOptions.containsLowercaseLetter) {\n      status.containsLowercaseLetter ||= containsLowercaseCharacter;\n    }\n    if (this.customStrengthOptions.containsUppercaseLetter) {\n      status.containsUppercaseLetter ||= containsUppercaseCharacter;\n    }\n    if (this.customStrengthOptions.containsNumericCharacter) {\n      status.containsNumericCharacter ||= containsNumericCharacter;\n    }\n    if (this.customStrengthOptions.containsNonAlphanumericCharacter) {\n      status.containsNonAlphanumericCharacter ||=\n        containsNonAlphanumericCharacter;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _isFirebaseServerApp,\n  _FirebaseService,\n  FirebaseApp\n} from '@firebase/app';\nimport { Provider } from '@firebase/component';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\nimport {\n  Auth,\n  AuthErrorMap,\n  AuthSettings,\n  EmulatorConfig,\n  NextOrObserver,\n  Persistence,\n  PopupRedirectResolver,\n  User,\n  UserCredential,\n  CompleteFn,\n  ErrorFn,\n  NextFn,\n  Unsubscribe,\n  PasswordValidationStatus\n} from '../../model/public_types';\nimport {\n  createSubscribe,\n  ErrorFactory,\n  FirebaseError,\n  getModularInstance,\n  Observer,\n  Subscribe\n} from '@firebase/util';\n\nimport { AuthInternal, ConfigInternal } from '../../model/auth';\nimport { PopupRedirectResolverInternal } from '../../model/popup_redirect';\nimport { UserInternal } from '../../model/user';\nimport {\n  AuthErrorCode,\n  AuthErrorParams,\n  ErrorMapRetriever,\n  _DEFAULT_AUTH_ERROR_FACTORY\n} from '../errors';\nimport { PersistenceInternal } from '../persistence';\nimport {\n  KeyName,\n  PersistenceUserManager\n} from '../persistence/persistence_user_manager';\nimport { _reloadWithoutSaving } from '../user/reload';\nimport {\n  _assert,\n  _serverAppCurrentUserOperationNotSupportedError\n} from '../util/assert';\nimport { _getInstance } from '../util/instantiator';\nimport { _getUserLanguage } from '../util/navigator';\nimport { _getClientVersion } from '../util/version';\nimport { HttpHeader } from '../../api';\nimport {\n  RevokeTokenRequest,\n  TokenType,\n  revokeToken\n} from '../../api/authentication/token';\nimport { AuthMiddlewareQueue } from './middleware';\nimport { RecaptchaConfig } from '../../platform_browser/recaptcha/recaptcha';\nimport { _logWarn } from '../util/log';\nimport { _getPasswordPolicy } from '../../api/password_policy/get_password_policy';\nimport { PasswordPolicyInternal } from '../../model/password_policy';\nimport { PasswordPolicyImpl } from './password_policy_impl';\nimport { getAccountInfo } from '../../api/account_management/account';\nimport { UserImpl } from '../user/user_impl';\n\ninterface AsyncAction {\n  (): Promise<void>;\n}\n\nexport const enum DefaultConfig {\n  TOKEN_API_HOST = 'securetoken.googleapis.com',\n  API_HOST = 'identitytoolkit.googleapis.com',\n  API_SCHEME = 'https'\n}\n\nexport class AuthImpl implements AuthInternal, _FirebaseService {\n  currentUser: User | null = null;\n  emulatorConfig: EmulatorConfig | null = null;\n  private operations = Promise.resolve();\n  private persistenceManager?: PersistenceUserManager;\n  private redirectPersistenceManager?: PersistenceUserManager;\n  private authStateSubscription = new Subscription<User>(this);\n  private idTokenSubscription = new Subscription<User>(this);\n  private readonly beforeStateQueue = new AuthMiddlewareQueue(this);\n  private redirectUser: UserInternal | null = null;\n  private isProactiveRefreshEnabled = false;\n  private readonly EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION: number = 1;\n\n  // Any network calls will set this to true and prevent subsequent emulator\n  // initialization\n  _canInitEmulator = true;\n  _isInitialized = false;\n  _deleted = false;\n  _initializationPromise: Promise<void> | null = null;\n  _popupRedirectResolver: PopupRedirectResolverInternal | null = null;\n  _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams> =\n    _DEFAULT_AUTH_ERROR_FACTORY;\n  _agentRecaptchaConfig: RecaptchaConfig | null = null;\n  _tenantRecaptchaConfigs: Record<string, RecaptchaConfig> = {};\n  _projectPasswordPolicy: PasswordPolicyInternal | null = null;\n  _tenantPasswordPolicies: Record<string, PasswordPolicyInternal> = {};\n  _resolvePersistenceManagerAvailable:\n    | ((value: void | PromiseLike<void>) => void)\n    | undefined = undefined;\n  _persistenceManagerAvailable: Promise<void>;\n  readonly name: string;\n\n  // Tracks the last notified UID for state change listeners to prevent\n  // repeated calls to the callbacks. Undefined means it's never been\n  // called, whereas null means it's been called with a signed out user\n  private lastNotifiedUid: string | null | undefined = undefined;\n\n  languageCode: string | null = null;\n  tenantId: string | null = null;\n  settings: AuthSettings = { appVerificationDisabledForTesting: false };\n\n  constructor(\n    public readonly app: FirebaseApp,\n    private readonly heartbeatServiceProvider: Provider<'heartbeat'>,\n    private readonly appCheckServiceProvider: Provider<AppCheckInternalComponentName>,\n    public readonly config: ConfigInternal\n  ) {\n    this.name = app.name;\n    this.clientVersion = config.sdkClientVersion;\n    // TODO(jamesdaniels) explore less hacky way to do this, cookie authentication needs\n    // persistenceMananger to be available. see _getFinalTarget for more context\n    this._persistenceManagerAvailable = new Promise<void>(\n      resolve => (this._resolvePersistenceManagerAvailable = resolve)\n    );\n  }\n\n  _initializeWithPersistence(\n    persistenceHierarchy: PersistenceInternal[],\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    if (popupRedirectResolver) {\n      this._popupRedirectResolver = _getInstance(popupRedirectResolver);\n    }\n\n    // Have to check for app deletion throughout initialization (after each\n    // promise resolution)\n    this._initializationPromise = this.queue(async () => {\n      if (this._deleted) {\n        return;\n      }\n\n      this.persistenceManager = await PersistenceUserManager.create(\n        this,\n        persistenceHierarchy\n      );\n      this._resolvePersistenceManagerAvailable?.();\n\n      if (this._deleted) {\n        return;\n      }\n\n      // Initialize the resolver early if necessary (only applicable to web:\n      // this will cause the iframe to load immediately in certain cases)\n      if (this._popupRedirectResolver?._shouldInitProactively) {\n        // If this fails, don't halt auth loading\n        try {\n          await this._popupRedirectResolver._initialize(this);\n        } catch (e) {\n          /* Ignore the error */\n        }\n      }\n\n      await this.initializeCurrentUser(popupRedirectResolver);\n\n      this.lastNotifiedUid = this.currentUser?.uid || null;\n\n      if (this._deleted) {\n        return;\n      }\n\n      this._isInitialized = true;\n    });\n\n    return this._initializationPromise;\n  }\n\n  /**\n   * If the persistence is changed in another window, the user manager will let us know\n   */\n  async _onStorageEvent(): Promise<void> {\n    if (this._deleted) {\n      return;\n    }\n\n    const user = await this.assertedPersistence.getCurrentUser();\n\n    if (!this.currentUser && !user) {\n      // No change, do nothing (was signed out and remained signed out).\n      return;\n    }\n\n    // If the same user is to be synchronized.\n    if (this.currentUser && user && this.currentUser.uid === user.uid) {\n      // Data update, simply copy data changes.\n      this._currentUser._assign(user);\n      // If tokens changed from previous user tokens, this will trigger\n      // notifyAuthListeners_.\n      await this.currentUser.getIdToken();\n      return;\n    }\n\n    // Update current Auth state. Either a new login or logout.\n    // Skip blocking callbacks, they should not apply to a change in another tab.\n    await this._updateCurrentUser(user, /* skipBeforeStateCallbacks */ true);\n  }\n\n  private async initializeCurrentUserFromIdToken(\n    idToken: string\n  ): Promise<void> {\n    try {\n      const response = await getAccountInfo(this, { idToken });\n      const user = await UserImpl._fromGetAccountInfoResponse(\n        this,\n        response,\n        idToken\n      );\n      await this.directlySetCurrentUser(user);\n    } catch (err) {\n      console.warn(\n        'FirebaseServerApp could not login user with provided authIdToken: ',\n        err\n      );\n      await this.directlySetCurrentUser(null);\n    }\n  }\n\n  private async initializeCurrentUser(\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      const idToken = this.app.settings.authIdToken;\n      if (idToken) {\n        // Start the auth operation in the next tick to allow a moment for the customer's app to\n        // attach an emulator, if desired.\n        return new Promise<void>(resolve => {\n          setTimeout(() =>\n            this.initializeCurrentUserFromIdToken(idToken).then(\n              resolve,\n              resolve\n            )\n          );\n        });\n      } else {\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    // First check to see if we have a pending redirect event.\n    const previouslyStoredUser =\n      (await this.assertedPersistence.getCurrentUser()) as UserInternal | null;\n    let futureCurrentUser = previouslyStoredUser;\n    let needsTocheckMiddleware = false;\n    if (popupRedirectResolver && this.config.authDomain) {\n      await this.getOrInitRedirectPersistenceManager();\n      const redirectUserEventId = this.redirectUser?._redirectEventId;\n      const storedUserEventId = futureCurrentUser?._redirectEventId;\n      const result = await this.tryRedirectSignIn(popupRedirectResolver);\n\n      // If the stored user (i.e. the old \"currentUser\") has a redirectId that\n      // matches the redirect user, then we want to initially sign in with the\n      // new user object from result.\n      // TODO(samgho): More thoroughly test all of this\n      if (\n        (!redirectUserEventId || redirectUserEventId === storedUserEventId) &&\n        result?.user\n      ) {\n        futureCurrentUser = result.user as UserInternal;\n        needsTocheckMiddleware = true;\n      }\n    }\n\n    // If no user in persistence, there is no current user. Set to null.\n    if (!futureCurrentUser) {\n      return this.directlySetCurrentUser(null);\n    }\n\n    if (!futureCurrentUser._redirectEventId) {\n      // This isn't a redirect link operation, we can reload and bail.\n      // First though, ensure that we check the middleware is happy.\n      if (needsTocheckMiddleware) {\n        try {\n          await this.beforeStateQueue.runMiddleware(futureCurrentUser);\n        } catch (e) {\n          futureCurrentUser = previouslyStoredUser;\n          // We know this is available since the bit is only set when the\n          // resolver is available\n          this._popupRedirectResolver!._overrideRedirectResult(this, () =>\n            Promise.reject(e)\n          );\n        }\n      }\n\n      if (futureCurrentUser) {\n        return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);\n      } else {\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    _assert(this._popupRedirectResolver, this, AuthErrorCode.ARGUMENT_ERROR);\n    await this.getOrInitRedirectPersistenceManager();\n\n    // If the redirect user's event ID matches the current user's event ID,\n    // DO NOT reload the current user, otherwise they'll be cleared from storage.\n    // This is important for the reauthenticateWithRedirect() flow.\n    if (\n      this.redirectUser &&\n      this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId\n    ) {\n      return this.directlySetCurrentUser(futureCurrentUser);\n    }\n\n    return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);\n  }\n\n  private async tryRedirectSignIn(\n    redirectResolver: PopupRedirectResolver\n  ): Promise<UserCredential | null> {\n    // The redirect user needs to be checked (and signed in if available)\n    // during auth initialization. All of the normal sign in and link/reauth\n    // flows call back into auth and push things onto the promise queue. We\n    // need to await the result of the redirect sign in *inside the promise\n    // queue*. This presents a problem: we run into deadlock. See:\n    //    ┌> [Initialization] ─────┐\n    //    ┌> [<other queue tasks>] │\n    //    └─ [getRedirectResult] <─┘\n    //    where [] are tasks on the queue and arrows denote awaits\n    // Initialization will never complete because it's waiting on something\n    // that's waiting for initialization to complete!\n    //\n    // Instead, this method calls getRedirectResult() (stored in\n    // _completeRedirectFn) with an optional parameter that instructs all of\n    // the underlying auth operations to skip anything that mutates auth state.\n\n    let result: UserCredential | null = null;\n    try {\n      // We know this._popupRedirectResolver is set since redirectResolver\n      // is passed in. The _completeRedirectFn expects the unwrapped extern.\n      result = await this._popupRedirectResolver!._completeRedirectFn(\n        this,\n        redirectResolver,\n        true\n      );\n    } catch (e) {\n      // Swallow any errors here; the code can retrieve them in\n      // getRedirectResult().\n      await this._setRedirectUser(null);\n    }\n\n    return result;\n  }\n\n  private async reloadAndSetCurrentUserOrClear(\n    user: UserInternal\n  ): Promise<void> {\n    try {\n      await _reloadWithoutSaving(user);\n    } catch (e) {\n      if (\n        (e as FirebaseError)?.code !==\n        `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`\n      ) {\n        // Something's wrong with the user's token. Log them out and remove\n        // them from storage\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    return this.directlySetCurrentUser(user);\n  }\n\n  useDeviceLanguage(): void {\n    this.languageCode = _getUserLanguage();\n  }\n\n  async _delete(): Promise<void> {\n    this._deleted = true;\n  }\n\n  async updateCurrentUser(userExtern: User | null): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this)\n      );\n    }\n    // The public updateCurrentUser method needs to make a copy of the user,\n    // and also check that the project matches\n    const user = userExtern\n      ? (getModularInstance(userExtern) as UserInternal)\n      : null;\n    if (user) {\n      _assert(\n        user.auth.config.apiKey === this.config.apiKey,\n        this,\n        AuthErrorCode.INVALID_AUTH\n      );\n    }\n    return this._updateCurrentUser(user && user._clone(this));\n  }\n\n  async _updateCurrentUser(\n    user: User | null,\n    skipBeforeStateCallbacks: boolean = false\n  ): Promise<void> {\n    if (this._deleted) {\n      return;\n    }\n    if (user) {\n      _assert(\n        this.tenantId === user.tenantId,\n        this,\n        AuthErrorCode.TENANT_ID_MISMATCH\n      );\n    }\n\n    if (!skipBeforeStateCallbacks) {\n      await this.beforeStateQueue.runMiddleware(user);\n    }\n\n    return this.queue(async () => {\n      await this.directlySetCurrentUser(user as UserInternal | null);\n      this.notifyAuthListeners();\n    });\n  }\n\n  async signOut(): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this)\n      );\n    }\n    // Run first, to block _setRedirectUser() if any callbacks fail.\n    await this.beforeStateQueue.runMiddleware(null);\n    // Clear the redirect user when signOut is called\n    if (this.redirectPersistenceManager || this._popupRedirectResolver) {\n      await this._setRedirectUser(null);\n    }\n\n    // Prevent callbacks from being called again in _updateCurrentUser, as\n    // they were already called in the first line.\n    return this._updateCurrentUser(null, /* skipBeforeStateCallbacks */ true);\n  }\n\n  setPersistence(persistence: Persistence): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this)\n      );\n    }\n    return this.queue(async () => {\n      await this.assertedPersistence.setPersistence(_getInstance(persistence));\n    });\n  }\n\n  _getRecaptchaConfig(): RecaptchaConfig | null {\n    if (this.tenantId == null) {\n      return this._agentRecaptchaConfig;\n    } else {\n      return this._tenantRecaptchaConfigs[this.tenantId];\n    }\n  }\n\n  async validatePassword(password: string): Promise<PasswordValidationStatus> {\n    if (!this._getPasswordPolicyInternal()) {\n      await this._updatePasswordPolicy();\n    }\n\n    // Password policy will be defined after fetching.\n    const passwordPolicy: PasswordPolicyInternal =\n      this._getPasswordPolicyInternal()!;\n\n    // Check that the policy schema version is supported by the SDK.\n    // TODO: Update this logic to use a max supported policy schema version once we have multiple schema versions.\n    if (\n      passwordPolicy.schemaVersion !==\n      this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION\n    ) {\n      return Promise.reject(\n        this._errorFactory.create(\n          AuthErrorCode.UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION,\n          {}\n        )\n      );\n    }\n\n    return passwordPolicy.validatePassword(password);\n  }\n\n  _getPasswordPolicyInternal(): PasswordPolicyInternal | null {\n    if (this.tenantId === null) {\n      return this._projectPasswordPolicy;\n    } else {\n      return this._tenantPasswordPolicies[this.tenantId];\n    }\n  }\n\n  async _updatePasswordPolicy(): Promise<void> {\n    const response = await _getPasswordPolicy(this);\n\n    const passwordPolicy: PasswordPolicyInternal = new PasswordPolicyImpl(\n      response\n    );\n\n    if (this.tenantId === null) {\n      this._projectPasswordPolicy = passwordPolicy;\n    } else {\n      this._tenantPasswordPolicies[this.tenantId] = passwordPolicy;\n    }\n  }\n\n  _getPersistenceType(): string {\n    return this.assertedPersistence.persistence.type;\n  }\n\n  _getPersistence(): PersistenceInternal {\n    return this.assertedPersistence.persistence;\n  }\n\n  _updateErrorMap(errorMap: AuthErrorMap): void {\n    this._errorFactory = new ErrorFactory<AuthErrorCode, AuthErrorParams>(\n      'auth',\n      'Firebase',\n      (errorMap as ErrorMapRetriever)()\n    );\n  }\n\n  onAuthStateChanged(\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    return this.registerStateListener(\n      this.authStateSubscription,\n      nextOrObserver,\n      error,\n      completed\n    );\n  }\n\n  beforeAuthStateChanged(\n    callback: (user: User | null) => void | Promise<void>,\n    onAbort?: () => void\n  ): Unsubscribe {\n    return this.beforeStateQueue.pushCallback(callback, onAbort);\n  }\n\n  onIdTokenChanged(\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    return this.registerStateListener(\n      this.idTokenSubscription,\n      nextOrObserver,\n      error,\n      completed\n    );\n  }\n\n  authStateReady(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if (this.currentUser) {\n        resolve();\n      } else {\n        const unsubscribe = this.onAuthStateChanged(() => {\n          unsubscribe();\n          resolve();\n        }, reject);\n      }\n    });\n  }\n\n  /**\n   * Revokes the given access token. Currently only supports Apple OAuth access tokens.\n   */\n  async revokeAccessToken(token: string): Promise<void> {\n    if (this.currentUser) {\n      const idToken = await this.currentUser.getIdToken();\n      // Generalize this to accept other providers once supported.\n      const request: RevokeTokenRequest = {\n        providerId: 'apple.com',\n        tokenType: TokenType.ACCESS_TOKEN,\n        token,\n        idToken\n      };\n      if (this.tenantId != null) {\n        request.tenantId = this.tenantId;\n      }\n      await revokeToken(this, request);\n    }\n  }\n\n  toJSON(): object {\n    return {\n      apiKey: this.config.apiKey,\n      authDomain: this.config.authDomain,\n      appName: this.name,\n      currentUser: this._currentUser?.toJSON()\n    };\n  }\n\n  async _setRedirectUser(\n    user: UserInternal | null,\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    const redirectManager = await this.getOrInitRedirectPersistenceManager(\n      popupRedirectResolver\n    );\n    return user === null\n      ? redirectManager.removeCurrentUser()\n      : redirectManager.setCurrentUser(user);\n  }\n\n  private async getOrInitRedirectPersistenceManager(\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<PersistenceUserManager> {\n    if (!this.redirectPersistenceManager) {\n      const resolver: PopupRedirectResolverInternal | null =\n        (popupRedirectResolver && _getInstance(popupRedirectResolver)) ||\n        this._popupRedirectResolver;\n      _assert(resolver, this, AuthErrorCode.ARGUMENT_ERROR);\n      this.redirectPersistenceManager = await PersistenceUserManager.create(\n        this,\n        [_getInstance(resolver._redirectPersistence)],\n        KeyName.REDIRECT_USER\n      );\n      this.redirectUser =\n        await this.redirectPersistenceManager.getCurrentUser();\n    }\n\n    return this.redirectPersistenceManager;\n  }\n\n  async _redirectUserForId(id: string): Promise<UserInternal | null> {\n    // Make sure we've cleared any pending persistence actions if we're not in\n    // the initializer\n    if (this._isInitialized) {\n      await this.queue(async () => {});\n    }\n\n    if (this._currentUser?._redirectEventId === id) {\n      return this._currentUser;\n    }\n\n    if (this.redirectUser?._redirectEventId === id) {\n      return this.redirectUser;\n    }\n\n    return null;\n  }\n\n  async _persistUserIfCurrent(user: UserInternal): Promise<void> {\n    if (user === this.currentUser) {\n      return this.queue(async () => this.directlySetCurrentUser(user));\n    }\n  }\n\n  /** Notifies listeners only if the user is current */\n  _notifyListenersIfCurrent(user: UserInternal): void {\n    if (user === this.currentUser) {\n      this.notifyAuthListeners();\n    }\n  }\n\n  _key(): string {\n    return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;\n  }\n\n  _startProactiveRefresh(): void {\n    this.isProactiveRefreshEnabled = true;\n    if (this.currentUser) {\n      this._currentUser._startProactiveRefresh();\n    }\n  }\n\n  _stopProactiveRefresh(): void {\n    this.isProactiveRefreshEnabled = false;\n    if (this.currentUser) {\n      this._currentUser._stopProactiveRefresh();\n    }\n  }\n\n  /** Returns the current user cast as the internal type */\n  get _currentUser(): UserInternal {\n    return this.currentUser as UserInternal;\n  }\n\n  private notifyAuthListeners(): void {\n    if (!this._isInitialized) {\n      return;\n    }\n\n    this.idTokenSubscription.next(this.currentUser);\n\n    const currentUid = this.currentUser?.uid ?? null;\n    if (this.lastNotifiedUid !== currentUid) {\n      this.lastNotifiedUid = currentUid;\n      this.authStateSubscription.next(this.currentUser);\n    }\n  }\n\n  private registerStateListener(\n    subscription: Subscription<User>,\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    if (this._deleted) {\n      return () => {};\n    }\n\n    const cb =\n      typeof nextOrObserver === 'function'\n        ? nextOrObserver\n        : nextOrObserver.next.bind(nextOrObserver);\n\n    let isUnsubscribed = false;\n\n    const promise = this._isInitialized\n      ? Promise.resolve()\n      : this._initializationPromise;\n    _assert(promise, this, AuthErrorCode.INTERNAL_ERROR);\n    // The callback needs to be called asynchronously per the spec.\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    promise.then(() => {\n      if (isUnsubscribed) {\n        return;\n      }\n      cb(this.currentUser);\n    });\n\n    if (typeof nextOrObserver === 'function') {\n      const unsubscribe = subscription.addObserver(\n        nextOrObserver,\n        error,\n        completed\n      );\n      return () => {\n        isUnsubscribed = true;\n        unsubscribe();\n      };\n    } else {\n      const unsubscribe = subscription.addObserver(nextOrObserver);\n      return () => {\n        isUnsubscribed = true;\n        unsubscribe();\n      };\n    }\n  }\n\n  /**\n   * Unprotected (from race conditions) method to set the current user. This\n   * should only be called from within a queued callback. This is necessary\n   * because the queue shouldn't rely on another queued callback.\n   */\n  private async directlySetCurrentUser(\n    user: UserInternal | null\n  ): Promise<void> {\n    if (this.currentUser && this.currentUser !== user) {\n      this._currentUser._stopProactiveRefresh();\n    }\n    if (user && this.isProactiveRefreshEnabled) {\n      user._startProactiveRefresh();\n    }\n\n    this.currentUser = user;\n\n    if (user) {\n      await this.assertedPersistence.setCurrentUser(user);\n    } else {\n      await this.assertedPersistence.removeCurrentUser();\n    }\n  }\n\n  private queue(action: AsyncAction): Promise<void> {\n    // In case something errors, the callback still should be called in order\n    // to keep the promise chain alive\n    this.operations = this.operations.then(action, action);\n    return this.operations;\n  }\n\n  private get assertedPersistence(): PersistenceUserManager {\n    _assert(this.persistenceManager, this, AuthErrorCode.INTERNAL_ERROR);\n    return this.persistenceManager;\n  }\n\n  private frameworks: string[] = [];\n  private clientVersion: string;\n  _logFramework(framework: string): void {\n    if (!framework || this.frameworks.includes(framework)) {\n      return;\n    }\n    this.frameworks.push(framework);\n\n    // Sort alphabetically so that \"FirebaseCore-web,FirebaseUI-web\" and\n    // \"FirebaseUI-web,FirebaseCore-web\" aren't viewed as different.\n    this.frameworks.sort();\n    this.clientVersion = _getClientVersion(\n      this.config.clientPlatform,\n      this._getFrameworks()\n    );\n  }\n  _getFrameworks(): readonly string[] {\n    return this.frameworks;\n  }\n  async _getAdditionalHeaders(): Promise<Record<string, string>> {\n    // Additional headers on every request\n    const headers: Record<string, string> = {\n      [HttpHeader.X_CLIENT_VERSION]: this.clientVersion\n    };\n\n    if (this.app.options.appId) {\n      headers[HttpHeader.X_FIREBASE_GMPID] = this.app.options.appId;\n    }\n\n    // If the heartbeat service exists, add the heartbeat string\n    const heartbeatsHeader = await this.heartbeatServiceProvider\n      .getImmediate({\n        optional: true\n      })\n      ?.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers[HttpHeader.X_FIREBASE_CLIENT] = heartbeatsHeader;\n    }\n\n    // If the App Check service exists, add the App Check token in the headers\n    const appCheckToken = await this._getAppCheckToken();\n    if (appCheckToken) {\n      headers[HttpHeader.X_FIREBASE_APP_CHECK] = appCheckToken;\n    }\n\n    return headers;\n  }\n\n  async _getAppCheckToken(): Promise<string | undefined> {\n    if (_isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {\n      return this.app.settings.appCheckToken;\n    }\n    const appCheckTokenResult = await this.appCheckServiceProvider\n      .getImmediate({ optional: true })\n      ?.getToken();\n    if (appCheckTokenResult?.error) {\n      // Context: appCheck.getToken() will never throw even if an error happened.\n      // In the error case, a dummy token will be returned along with an error field describing\n      // the error. In general, we shouldn't care about the error condition and just use\n      // the token (actual or dummy) to send requests.\n      _logWarn(\n        `Error while retrieving App Check token: ${appCheckTokenResult.error}`\n      );\n    }\n    return appCheckTokenResult?.token;\n  }\n}\n\n/**\n * Method to be used to cast down to our private implementation of Auth.\n * It will also handle unwrapping from the compat type if necessary\n *\n * @param auth Auth object passed in from developer\n */\nexport function _castAuth(auth: Auth): AuthInternal {\n  return getModularInstance(auth) as AuthInternal;\n}\n\n/** Helper class to wrap subscriber logic */\nclass Subscription<T> {\n  private observer: Observer<T | null> | null = null;\n  readonly addObserver: Subscribe<T | null> = createSubscribe(\n    observer => (this.observer = observer)\n  );\n\n  constructor(readonly auth: AuthInternal) {}\n\n  get next(): NextFn<T | null> {\n    _assert(this.observer, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    return this.observer.next.bind(this.observer);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\ninterface ExternalJSProvider {\n  loadJS(url: string): Promise<Event>;\n  recaptchaV2Script: string;\n  recaptchaEnterpriseScript: string;\n  gapiScript: string;\n}\n\nlet externalJSProvider: ExternalJSProvider = {\n  async loadJS() {\n    throw new Error('Unable to load external scripts');\n  },\n\n  recaptchaV2Script: '',\n  recaptchaEnterpriseScript: '',\n  gapiScript: ''\n};\n\nexport function _setExternalJSProvider(p: ExternalJSProvider): void {\n  externalJSProvider = p;\n}\n\nexport function _loadJS(url: string): Promise<Event> {\n  return externalJSProvider.loadJS(url);\n}\n\nexport function _recaptchaV2ScriptUrl(): string {\n  return externalJSProvider.recaptchaV2Script;\n}\n\nexport function _recaptchaEnterpriseScriptUrl(): string {\n  return externalJSProvider.recaptchaEnterpriseScript;\n}\n\nexport function _gapiScriptUrl(): string {\n  return externalJSProvider.gapiScript;\n}\n\nexport function _generateCallbackName(prefix: string): string {\n  return `__${prefix}${Math.floor(Math.random() * 1000000)}`;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\nimport { AuthInternal } from '../../model/auth';\nimport { RecaptchaParameters } from '../../model/public_types';\nimport {\n  Recaptcha,\n  GreCAPTCHATopLevel,\n  GreCAPTCHARenderOption,\n  GreCAPTCHA\n} from './recaptcha';\n\nexport const _SOLVE_TIME_MS = 500;\nexport const _EXPIRATION_TIME_MS = 60_000;\nexport const _WIDGET_ID_START = 1_000_000_000_000;\n\nexport interface Widget {\n  getResponse: () => string | null;\n  delete: () => void;\n  execute: () => void;\n}\n\nexport class MockReCaptcha implements Recaptcha {\n  private counter = _WIDGET_ID_START;\n  _widgets = new Map<number, Widget>();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  render(\n    container: string | HTMLElement,\n    parameters?: RecaptchaParameters\n  ): number {\n    const id = this.counter;\n    this._widgets.set(\n      id,\n      new MockWidget(container, this.auth.name, parameters || {})\n    );\n    this.counter++;\n    return id;\n  }\n\n  reset(optWidgetId?: number): void {\n    const id = optWidgetId || _WIDGET_ID_START;\n    void this._widgets.get(id)?.delete();\n    this._widgets.delete(id);\n  }\n\n  getResponse(optWidgetId?: number): string {\n    const id = optWidgetId || _WIDGET_ID_START;\n    return this._widgets.get(id)?.getResponse() || '';\n  }\n\n  async execute(optWidgetId?: number | string): Promise<string> {\n    const id: number = (optWidgetId as number) || _WIDGET_ID_START;\n    void this._widgets.get(id)?.execute();\n    return '';\n  }\n}\n\nexport class MockGreCAPTCHATopLevel implements GreCAPTCHATopLevel {\n  enterprise: GreCAPTCHA = new MockGreCAPTCHA();\n  ready(callback: () => void): void {\n    callback();\n  }\n\n  execute(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _siteKey: string,\n    _options: { action: string }\n  ): Promise<string> {\n    return Promise.resolve('token');\n  }\n  render(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _container: string | HTMLElement,\n    _parameters: GreCAPTCHARenderOption\n  ): string {\n    return '';\n  }\n}\n\nexport class MockGreCAPTCHA implements GreCAPTCHA {\n  ready(callback: () => void): void {\n    callback();\n  }\n\n  execute(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _siteKey: string,\n    _options: { action: string }\n  ): Promise<string> {\n    return Promise.resolve('token');\n  }\n  render(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _container: string | HTMLElement,\n    _parameters: GreCAPTCHARenderOption\n  ): string {\n    return '';\n  }\n}\n\nexport class MockWidget {\n  private readonly container: HTMLElement;\n  private readonly isVisible: boolean;\n  private timerId: number | null = null;\n  private deleted = false;\n  private responseToken: string | null = null;\n  private readonly clickHandler = (): void => {\n    this.execute();\n  };\n\n  constructor(\n    containerOrId: string | HTMLElement,\n    appName: string,\n    private readonly params: RecaptchaParameters\n  ) {\n    const container =\n      typeof containerOrId === 'string'\n        ? document.getElementById(containerOrId)\n        : containerOrId;\n    _assert(container, AuthErrorCode.ARGUMENT_ERROR, { appName });\n\n    this.container = container;\n    this.isVisible = this.params.size !== 'invisible';\n    if (this.isVisible) {\n      this.execute();\n    } else {\n      this.container.addEventListener('click', this.clickHandler);\n    }\n  }\n\n  getResponse(): string | null {\n    this.checkIfDeleted();\n    return this.responseToken;\n  }\n\n  delete(): void {\n    this.checkIfDeleted();\n    this.deleted = true;\n    if (this.timerId) {\n      clearTimeout(this.timerId);\n      this.timerId = null;\n    }\n    this.container.removeEventListener('click', this.clickHandler);\n  }\n\n  execute(): void {\n    this.checkIfDeleted();\n    if (this.timerId) {\n      return;\n    }\n\n    this.timerId = window.setTimeout(() => {\n      this.responseToken = generateRandomAlphaNumericString(50);\n      const { callback, 'expired-callback': expiredCallback } = this.params;\n      if (callback) {\n        try {\n          callback(this.responseToken);\n        } catch (e) {}\n      }\n\n      this.timerId = window.setTimeout(() => {\n        this.timerId = null;\n        this.responseToken = null;\n        if (expiredCallback) {\n          try {\n            expiredCallback();\n          } catch (e) {}\n        }\n\n        if (this.isVisible) {\n          this.execute();\n        }\n      }, _EXPIRATION_TIME_MS);\n    }, _SOLVE_TIME_MS);\n  }\n\n  private checkIfDeleted(): void {\n    if (this.deleted) {\n      throw new Error('reCAPTCHA mock was already deleted!');\n    }\n  }\n}\n\nfunction generateRandomAlphaNumericString(len: number): string {\n  const chars = [];\n  const allowedChars =\n    '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\n  for (let i = 0; i < len; i++) {\n    chars.push(\n      allowedChars.charAt(Math.floor(Math.random() * allowedChars.length))\n    );\n  }\n  return chars.join('');\n}\n", "/* eslint-disable @typescript-eslint/no-require-imports */\n/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isEnterprise, RecaptchaConfig } from './recaptcha';\nimport { getRecaptchaConfig } from '../../api/authentication/recaptcha';\nimport {\n  RecaptchaClientType,\n  RecaptchaVersion,\n  RecaptchaActionName,\n  RecaptchaAuthProvider,\n  EnforcementState\n} from '../../api';\n\nimport { Auth } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport * as jsHelpers from '../load_js';\nimport { AuthErrorCode } from '../../core/errors';\nimport { StartPhoneMfaEnrollmentRequest } from '../../api/account_management/mfa';\nimport { StartPhoneMfaSignInRequest } from '../../api/authentication/mfa';\nimport { MockGreCAPTCHATopLevel } from './recaptcha_mock';\n\nexport const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = 'recaptcha-enterprise';\nexport const FAKE_TOKEN = 'NO_RECAPTCHA';\n\nexport class RecaptchaEnterpriseVerifier {\n  /**\n   * Identifies the type of application verifier (e.g. \"recaptcha-enterprise\").\n   */\n  readonly type = RECAPTCHA_ENTERPRISE_VERIFIER_TYPE;\n\n  private readonly auth: AuthInternal;\n\n  /**\n   *\n   * @param authExtern - The corresponding Firebase {@link Auth} instance.\n   *\n   */\n  constructor(authExtern: Auth) {\n    this.auth = _castAuth(authExtern);\n  }\n\n  /**\n   * Executes the verification process.\n   *\n   * @returns A Promise for a token that can be used to assert the validity of a request.\n   */\n  async verify(\n    action: string = 'verify',\n    forceRefresh = false\n  ): Promise<string> {\n    async function retrieveSiteKey(auth: AuthInternal): Promise<string> {\n      if (!forceRefresh) {\n        if (auth.tenantId == null && auth._agentRecaptchaConfig != null) {\n          return auth._agentRecaptchaConfig.siteKey;\n        }\n        if (\n          auth.tenantId != null &&\n          auth._tenantRecaptchaConfigs[auth.tenantId] !== undefined\n        ) {\n          return auth._tenantRecaptchaConfigs[auth.tenantId].siteKey;\n        }\n      }\n\n      return new Promise<string>(async (resolve, reject) => {\n        getRecaptchaConfig(auth, {\n          clientType: RecaptchaClientType.WEB,\n          version: RecaptchaVersion.ENTERPRISE\n        })\n          .then(response => {\n            if (response.recaptchaKey === undefined) {\n              reject(new Error('recaptcha Enterprise site key undefined'));\n            } else {\n              const config = new RecaptchaConfig(response);\n              if (auth.tenantId == null) {\n                auth._agentRecaptchaConfig = config;\n              } else {\n                auth._tenantRecaptchaConfigs[auth.tenantId] = config;\n              }\n              return resolve(config.siteKey);\n            }\n          })\n          .catch(error => {\n            reject(error);\n          });\n      });\n    }\n\n    function retrieveRecaptchaToken(\n      siteKey: string,\n      resolve: (value: string | PromiseLike<string>) => void,\n      reject: (reason?: unknown) => void\n    ): void {\n      const grecaptcha = window.grecaptcha;\n      if (isEnterprise(grecaptcha)) {\n        grecaptcha.enterprise.ready(() => {\n          grecaptcha.enterprise\n            .execute(siteKey, { action })\n            .then(token => {\n              resolve(token);\n            })\n            .catch(() => {\n              resolve(FAKE_TOKEN);\n            });\n        });\n      } else {\n        reject(Error('No reCAPTCHA enterprise script loaded.'));\n      }\n    }\n\n    // Returns Promise for a mock token when appVerificationDisabledForTesting is true.\n    if (this.auth.settings.appVerificationDisabledForTesting) {\n      const mockRecaptcha = new MockGreCAPTCHATopLevel();\n      return mockRecaptcha.execute('siteKey', { action: 'verify' });\n    }\n\n    return new Promise<string>((resolve, reject) => {\n      retrieveSiteKey(this.auth)\n        .then(siteKey => {\n          if (!forceRefresh && isEnterprise(window.grecaptcha)) {\n            retrieveRecaptchaToken(siteKey, resolve, reject);\n          } else {\n            if (typeof window === 'undefined') {\n              reject(\n                new Error('RecaptchaVerifier is only supported in browser')\n              );\n              return;\n            }\n            let url = jsHelpers._recaptchaEnterpriseScriptUrl();\n            if (url.length !== 0) {\n              url += siteKey;\n            }\n            jsHelpers\n              ._loadJS(url)\n              .then(() => {\n                retrieveRecaptchaToken(siteKey, resolve, reject);\n              })\n              .catch(error => {\n                reject(error);\n              });\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  }\n}\n\nexport async function injectRecaptchaFields<T extends object>(\n  auth: AuthInternal,\n  request: T,\n  action: RecaptchaActionName,\n  isCaptchaResp = false,\n  isFakeToken = false\n): Promise<T> {\n  const verifier = new RecaptchaEnterpriseVerifier(auth);\n  let captchaResponse;\n\n  if (isFakeToken) {\n    captchaResponse = FAKE_TOKEN;\n  } else {\n    try {\n      captchaResponse = await verifier.verify(action);\n    } catch (error) {\n      captchaResponse = await verifier.verify(action, true);\n    }\n  }\n\n  const newRequest = { ...request };\n  if (\n    action === RecaptchaActionName.MFA_SMS_ENROLLMENT ||\n    action === RecaptchaActionName.MFA_SMS_SIGNIN\n  ) {\n    if ('phoneEnrollmentInfo' in newRequest) {\n      const phoneNumber = (\n        newRequest as unknown as StartPhoneMfaEnrollmentRequest\n      ).phoneEnrollmentInfo.phoneNumber;\n      const recaptchaToken = (\n        newRequest as unknown as StartPhoneMfaEnrollmentRequest\n      ).phoneEnrollmentInfo.recaptchaToken;\n\n      Object.assign(newRequest, {\n        'phoneEnrollmentInfo': {\n          phoneNumber,\n          recaptchaToken,\n          captchaResponse,\n          'clientType': RecaptchaClientType.WEB,\n          'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n        }\n      });\n    } else if ('phoneSignInInfo' in newRequest) {\n      const recaptchaToken = (\n        newRequest as unknown as StartPhoneMfaSignInRequest\n      ).phoneSignInInfo.recaptchaToken;\n\n      Object.assign(newRequest, {\n        'phoneSignInInfo': {\n          recaptchaToken,\n          captchaResponse,\n          'clientType': RecaptchaClientType.WEB,\n          'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n        }\n      });\n    }\n    return newRequest;\n  }\n\n  if (!isCaptchaResp) {\n    Object.assign(newRequest, { captchaResponse });\n  } else {\n    Object.assign(newRequest, { 'captchaResp': captchaResponse });\n  }\n  Object.assign(newRequest, { 'clientType': RecaptchaClientType.WEB });\n  Object.assign(newRequest, {\n    'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n  });\n  return newRequest;\n}\n\ntype ActionMethod<TRequest, TResponse> = (\n  auth: AuthInternal,\n  request: TRequest\n) => Promise<TResponse>;\n\nexport async function handleRecaptchaFlow<TRequest extends object, TResponse>(\n  authInstance: AuthInternal,\n  request: TRequest,\n  actionName: RecaptchaActionName,\n  actionMethod: ActionMethod<TRequest, TResponse>,\n  recaptchaAuthProvider: RecaptchaAuthProvider\n): Promise<TResponse> {\n  if (recaptchaAuthProvider === RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER) {\n    if (\n      authInstance\n        ._getRecaptchaConfig()\n        ?.isProviderEnabled(RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER)\n    ) {\n      const requestWithRecaptcha = await injectRecaptchaFields(\n        authInstance,\n        request,\n        actionName,\n        actionName === RecaptchaActionName.GET_OOB_CODE\n      );\n      return actionMethod(authInstance, requestWithRecaptcha);\n    } else {\n      return actionMethod(authInstance, request).catch(async error => {\n        if (error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}`) {\n          console.log(\n            `${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`\n          );\n          const requestWithRecaptcha = await injectRecaptchaFields(\n            authInstance,\n            request,\n            actionName,\n            actionName === RecaptchaActionName.GET_OOB_CODE\n          );\n          return actionMethod(authInstance, requestWithRecaptcha);\n        } else {\n          return Promise.reject(error);\n        }\n      });\n    }\n  } else if (recaptchaAuthProvider === RecaptchaAuthProvider.PHONE_PROVIDER) {\n    if (\n      authInstance\n        ._getRecaptchaConfig()\n        ?.isProviderEnabled(RecaptchaAuthProvider.PHONE_PROVIDER)\n    ) {\n      const requestWithRecaptcha = await injectRecaptchaFields(\n        authInstance,\n        request,\n        actionName\n      );\n\n      return actionMethod(authInstance, requestWithRecaptcha).catch(\n        async error => {\n          if (\n            authInstance\n              ._getRecaptchaConfig()\n              ?.getProviderEnforcementState(\n                RecaptchaAuthProvider.PHONE_PROVIDER\n              ) === EnforcementState.AUDIT\n          ) {\n            // AUDIT mode\n            if (\n              error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}` ||\n              error.code === `auth/${AuthErrorCode.INVALID_APP_CREDENTIAL}`\n            ) {\n              console.log(\n                `Failed to verify with reCAPTCHA Enterprise. Automatically triggering the reCAPTCHA v2 flow to complete the ${actionName} flow.`\n              );\n              // reCAPTCHA Enterprise token is missing or reCAPTCHA Enterprise token\n              // check fails.\n              // Fallback to reCAPTCHA v2 flow.\n              const requestWithRecaptchaFields = await injectRecaptchaFields(\n                authInstance,\n                request,\n                actionName,\n                false, // isCaptchaResp\n                true // isFakeToken\n              );\n              // This will call the PhoneApiCaller to fetch and inject reCAPTCHA v2 token.\n              return actionMethod(authInstance, requestWithRecaptchaFields);\n            }\n          }\n          // ENFORCE mode or AUDIT mode with any other error.\n          return Promise.reject(error);\n        }\n      );\n    } else {\n      // Do reCAPTCHA v2 flow.\n      const requestWithRecaptchaFields = await injectRecaptchaFields(\n        authInstance,\n        request,\n        actionName,\n        false, // isCaptchaResp\n        true // isFakeToken\n      );\n\n      // This will call the PhoneApiCaller to fetch and inject v2 token.\n      return actionMethod(authInstance, requestWithRecaptchaFields);\n    }\n  } else {\n    return Promise.reject(\n      recaptchaAuthProvider + ' provider is not supported.'\n    );\n  }\n}\n\nexport async function _initializeRecaptchaConfig(auth: Auth): Promise<void> {\n  const authInternal = _castAuth(auth);\n\n  const response = await getRecaptchaConfig(authInternal, {\n    clientType: RecaptchaClientType.WEB,\n    version: RecaptchaVersion.ENTERPRISE\n  });\n\n  const config = new RecaptchaConfig(response);\n  if (authInternal.tenantId == null) {\n    authInternal._agentRecaptchaConfig = config;\n  } else {\n    authInternal._tenantRecaptchaConfigs[authInternal.tenantId] = config;\n  }\n\n  if (config.isAnyProviderEnabled()) {\n    const verifier = new RecaptchaEnterpriseVerifier(authInternal);\n    void verifier.verify();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _getProvider, FirebaseApp } from '@firebase/app';\nimport { deepEqual } from '@firebase/util';\nimport { Auth, Dependencies } from '../../model/public_types';\n\nimport { AuthErrorCode } from '../errors';\nimport { PersistenceInternal } from '../persistence';\nimport { _fail } from '../util/assert';\nimport { _getInstance } from '../util/instantiator';\nimport { AuthImpl } from './auth_impl';\n\n/**\n * Initializes an {@link Auth} instance with fine-grained control over\n * {@link Dependencies}.\n *\n * @remarks\n *\n * This function allows more control over the {@link Auth} instance than\n * {@link getAuth}. `getAuth` uses platform-specific defaults to supply\n * the {@link Dependencies}. In general, `getAuth` is the easiest way to\n * initialize Auth and works for most use cases. Use `initializeAuth` if you\n * need control over which persistence layer is used, or to minimize bundle\n * size if you're not using either `signInWithPopup` or `signInWithRedirect`.\n *\n * For example, if your app only uses anonymous accounts and you only want\n * accounts saved for the current session, initialize `Auth` with:\n *\n * ```js\n * const auth = initializeAuth(app, {\n *   persistence: browserSessionPersistence,\n *   popupRedirectResolver: undefined,\n * });\n * ```\n *\n * @public\n */\nexport function initializeAuth(app: FirebaseApp, deps?: Dependencies): Auth {\n  const provider = _getProvider(app, 'auth');\n\n  if (provider.isInitialized()) {\n    const auth = provider.getImmediate() as AuthImpl;\n    const initialOptions = provider.getOptions() as Dependencies;\n    if (deepEqual(initialOptions, deps ?? {})) {\n      return auth;\n    } else {\n      _fail(auth, AuthErrorCode.ALREADY_INITIALIZED);\n    }\n  }\n\n  const auth = provider.initialize({ options: deps }) as AuthImpl;\n\n  return auth;\n}\n\nexport function _initializeAuthInstance(\n  auth: AuthImpl,\n  deps?: Dependencies\n): void {\n  const persistence = deps?.persistence || [];\n  const hierarchy = (\n    Array.isArray(persistence) ? persistence : [persistence]\n  ).map<PersistenceInternal>(_getInstance);\n  if (deps?.errorMap) {\n    auth._updateErrorMap(deps.errorMap);\n  }\n\n  // This promise is intended to float; auth initialization happens in the\n  // background, meanwhile the auth object may be used by the app.\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  auth._initializeWithPersistence(hierarchy, deps?.popupRedirectResolver);\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Auth } from '../../model/public_types';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _castAuth } from './auth_impl';\nimport {\n  deepEqual,\n  isCloudWorkstation,\n  pingServer,\n  updateEmulatorBanner\n} from '@firebase/util';\n\n/**\n * Changes the {@link Auth} instance to communicate with the Firebase Auth Emulator, instead of production\n * Firebase Auth services.\n *\n * @remarks\n * This must be called synchronously immediately following the first call to\n * {@link initializeAuth}.  Do not use with production credentials as emulator\n * traffic is not encrypted.\n *\n *\n * @example\n * ```javascript\n * connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param url - The URL at which the emulator is running (eg, 'http://localhost:9099').\n * @param options - Optional. `options.disableWarnings` defaults to `false`. Set it to\n * `true` to disable the warning banner attached to the DOM.\n *\n * @public\n */\nexport function connectAuthEmulator(\n  auth: Auth,\n  url: string,\n  options?: { disableWarnings: boolean }\n): void {\n  const authInternal = _castAuth(auth);\n  _assert(\n    /^https?:\\/\\//.test(url),\n    authInternal,\n    AuthErrorCode.INVALID_EMULATOR_SCHEME\n  );\n\n  const disableWarnings = !!options?.disableWarnings;\n\n  const protocol = extractProtocol(url);\n  const { host, port } = extractHostAndPort(url);\n  const portStr = port === null ? '' : `:${port}`;\n\n  // Always replace path with \"/\" (even if input url had no path at all, or had a different one).\n  const emulator = { url: `${protocol}//${host}${portStr}/` };\n  const emulatorConfig = Object.freeze({\n    host,\n    port,\n    protocol: protocol.replace(':', ''),\n    options: Object.freeze({ disableWarnings })\n  });\n\n  // There are a few scenarios to guard against if the Auth instance has already started:\n  if (!authInternal._canInitEmulator) {\n    // Applications may not initialize the emulator for the first time if Auth has already started\n    // to make network requests.\n    _assert(\n      authInternal.config.emulator && authInternal.emulatorConfig,\n      authInternal,\n      AuthErrorCode.EMULATOR_CONFIG_FAILED\n    );\n\n    // Applications may not alter the configuration of the emulator (aka pass a different config)\n    // once Auth has started to make network requests.\n    _assert(\n      deepEqual(emulator, authInternal.config.emulator) &&\n        deepEqual(emulatorConfig, authInternal.emulatorConfig),\n      authInternal,\n      AuthErrorCode.EMULATOR_CONFIG_FAILED\n    );\n\n    // It's valid, however, to invoke connectAuthEmulator() after Auth has started making\n    // connections, so long as the config matches the existing config. This results in a no-op.\n    return;\n  }\n\n  authInternal.config.emulator = emulator;\n  authInternal.emulatorConfig = emulatorConfig;\n  authInternal.settings.appVerificationDisabledForTesting = true;\n\n  // Workaround to get cookies in Firebase Studio\n  if (isCloudWorkstation(host)) {\n    void pingServer(`${protocol}//${host}${portStr}`);\n    updateEmulatorBanner('Auth', true);\n  } else if (!disableWarnings) {\n    emitEmulatorWarning();\n  }\n}\n\nfunction extractProtocol(url: string): string {\n  const protocolEnd = url.indexOf(':');\n  return protocolEnd < 0 ? '' : url.substr(0, protocolEnd + 1);\n}\n\nfunction extractHostAndPort(url: string): {\n  host: string;\n  port: number | null;\n} {\n  const protocol = extractProtocol(url);\n  const authority = /(\\/\\/)?([^?#/]+)/.exec(url.substr(protocol.length)); // Between // and /, ? or #.\n  if (!authority) {\n    return { host: '', port: null };\n  }\n  const hostAndPort = authority[2].split('@').pop() || ''; // Strip out \"username:password@\".\n  const bracketedIPv6 = /^(\\[[^\\]]+\\])(:|$)/.exec(hostAndPort);\n  if (bracketedIPv6) {\n    const host = bracketedIPv6[1];\n    return { host, port: parsePort(hostAndPort.substr(host.length + 1)) };\n  } else {\n    const [host, port] = hostAndPort.split(':');\n    return { host, port: parsePort(port) };\n  }\n}\n\nfunction parsePort(portStr: string): number | null {\n  if (!portStr) {\n    return null;\n  }\n  const port = Number(portStr);\n  if (isNaN(port)) {\n    return null;\n  }\n  return port;\n}\n\nfunction emitEmulatorWarning(): void {\n  function attachBanner(): void {\n    const el = document.createElement('p');\n    const sty = el.style;\n    el.innerText =\n      'Running in emulator mode. Do not use with production credentials.';\n    sty.position = 'fixed';\n    sty.width = '100%';\n    sty.backgroundColor = '#ffffff';\n    sty.border = '.1em solid #000000';\n    sty.color = '#b50000';\n    sty.bottom = '0px';\n    sty.left = '0px';\n    sty.margin = '0px';\n    sty.zIndex = '10000';\n    sty.textAlign = 'center';\n    el.classList.add('firebase-emulator-warning');\n    document.body.appendChild(el);\n  }\n\n  if (typeof console !== 'undefined' && typeof console.info === 'function') {\n    console.info(\n      'WARNING: You are using the Auth Emulator,' +\n        ' which is intended for local testing only.  Do not use with' +\n        ' production credentials.'\n    );\n  }\n  if (typeof window !== 'undefined' && typeof document !== 'undefined') {\n    if (document.readyState === 'loading') {\n      window.addEventListener('DOMContentLoaded', attachBanner);\n    } else {\n      attachBanner();\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { debugFail } from '../util/assert';\n\n/**\n * Interface that represents the credentials returned by an {@link AuthProvider}.\n *\n * @remarks\n * Implementations specify the details about each auth provider's credential requirements.\n *\n * @public\n */\nexport class AuthCredential {\n  /** @internal */\n  protected constructor(\n    /**\n     * The authentication provider ID for the credential.\n     *\n     * @remarks\n     * For example, 'facebook.com', or 'google.com'.\n     */\n    readonly providerId: string,\n    /**\n     * The authentication sign in method for the credential.\n     *\n     * @remarks\n     * For example, {@link SignInMethod}.EMAIL_PASSWORD, or\n     * {@link SignInMethod}.EMAIL_LINK. This corresponds to the sign-in method\n     * identifier as returned in {@link fetchSignInMethodsForEmail}.\n     */\n    readonly signInMethod: string\n  ) {}\n\n  /**\n   * Returns a JSON-serializable representation of this object.\n   *\n   * @returns a JSON-serializable representation of this object.\n   */\n  toJSON(): object {\n    return debugFail('not implemented');\n  }\n\n  /** @internal */\n  _getIdTokenResponse(_auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return debugFail('not implemented');\n  }\n  /** @internal */\n  _linkToIdToken(\n    _auth: AuthInternal,\n    _idToken: string\n  ): Promise<IdTokenResponse> {\n    return debugFail('not implemented');\n  }\n  /** @internal */\n  _getReauthenticationResolver(_auth: AuthInternal): Promise<IdTokenResponse> {\n    return debugFail('not implemented');\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeOperation, Auth } from '../../model/public_types';\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { MfaEnrollment } from './mfa';\nimport { SignUpRequest, SignUpResponse } from '../authentication/sign_up';\n\nexport interface ResetPasswordRequest {\n  oobCode: string;\n  newPassword?: string;\n  tenantId?: string;\n}\n\nexport interface ResetPasswordResponse {\n  email: string;\n  newEmail?: string;\n  requestType?: ActionCodeOperation;\n  mfaInfo?: MfaEnrollment;\n}\n\nexport async function resetPassword(\n  auth: Auth,\n  request: ResetPasswordRequest\n): Promise<ResetPasswordResponse> {\n  return _performApiRequest<ResetPasswordRequest, ResetPasswordResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.RESET_PASSWORD,\n    _addTidIfNecessary(auth, request)\n  );\n}\nexport interface UpdateEmailPasswordRequest {\n  idToken: string;\n  returnSecureToken?: boolean;\n  email?: string;\n  password?: string;\n}\n\nexport interface UpdateEmailPasswordResponse extends IdTokenResponse {}\n\nexport async function updateEmailPassword(\n  auth: Auth,\n  request: UpdateEmailPasswordRequest\n): Promise<UpdateEmailPasswordResponse> {\n  return _performApiRequest<\n    UpdateEmailPasswordRequest,\n    UpdateEmailPasswordResponse\n  >(auth, HttpMethod.POST, Endpoint.SET_ACCOUNT_INFO, request);\n}\n\n// Used for linking an email/password account to an existing idToken. Uses the same request/response\n// format as updateEmailPassword.\nexport async function linkEmailPassword(\n  auth: Auth,\n  request: SignUpRequest\n): Promise<SignUpResponse> {\n  return _performApiRequest<SignUpRequest, SignUpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_UP,\n    request\n  );\n}\n\nexport interface ApplyActionCodeRequest {\n  oobCode: string;\n  tenantId?: string;\n}\n\nexport interface ApplyActionCodeResponse {}\n\nexport async function applyActionCode(\n  auth: Auth,\n  request: ApplyActionCodeRequest\n): Promise<ApplyActionCodeResponse> {\n  return _performApiRequest<ApplyActionCodeRequest, ApplyActionCodeResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SET_ACCOUNT_INFO,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeOperation, Auth } from '../../model/public_types';\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _performApiRequest,\n  _performSignInRequest\n} from '../index';\nimport { IdToken, IdTokenResponse } from '../../model/id_token';\n\nexport interface SignInWithPasswordRequest {\n  returnSecureToken?: boolean;\n  email: string;\n  password: string;\n  tenantId?: string;\n  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface SignInWithPasswordResponse extends IdTokenResponse {\n  email: string;\n  displayName: string;\n}\n\nexport async function signInWithPassword(\n  auth: Auth,\n  request: SignInWithPasswordRequest\n): Promise<SignInWithPasswordResponse> {\n  return _performSignInRequest<\n    SignInWithPasswordRequest,\n    SignInWithPasswordResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PASSWORD,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface GetOobCodeRequest {\n  email?: string; // Everything except VERIFY_AND_CHANGE_EMAIL\n  continueUrl?: string;\n  iOSBundleId?: string;\n  iosAppStoreId?: string;\n  androidPackageName?: string;\n  androidInstallApp?: boolean;\n  androidMinimumVersionCode?: string;\n  canHandleCodeInApp?: boolean;\n  dynamicLinkDomain?: string;\n  tenantId?: string;\n  targetProjectid?: string;\n  linkDomain?: string;\n}\n\nexport interface VerifyEmailRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.VERIFY_EMAIL;\n  idToken: IdToken;\n}\n\nexport interface PasswordResetRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.PASSWORD_RESET;\n  email: string;\n  captchaResp?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface EmailSignInRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.EMAIL_SIGNIN;\n  email: string;\n  captchaResp?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface VerifyAndChangeEmailRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;\n  idToken: IdToken;\n  newEmail: string;\n}\n\ninterface GetOobCodeResponse {\n  email: string;\n}\n\nexport interface VerifyEmailResponse extends GetOobCodeResponse {}\nexport interface PasswordResetResponse extends GetOobCodeResponse {}\nexport interface EmailSignInResponse extends GetOobCodeResponse {}\nexport interface VerifyAndChangeEmailResponse extends GetOobCodeRequest {}\n\nasync function sendOobCode(\n  auth: Auth,\n  request: GetOobCodeRequest\n): Promise<GetOobCodeResponse> {\n  return _performApiRequest<GetOobCodeRequest, GetOobCodeResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SEND_OOB_CODE,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport async function sendEmailVerification(\n  auth: Auth,\n  request: VerifyEmailRequest\n): Promise<VerifyEmailResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function sendPasswordResetEmail(\n  auth: Auth,\n  request: PasswordResetRequest\n): Promise<PasswordResetResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function sendSignInLinkToEmail(\n  auth: Auth,\n  request: EmailSignInRequest\n): Promise<EmailSignInResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function verifyAndChangeEmail(\n  auth: Auth,\n  request: VerifyAndChangeEmailRequest\n): Promise<VerifyAndChangeEmailResponse> {\n  return sendOobCode(auth, request);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performSignInRequest,\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithEmailLinkRequest {\n  email: string;\n  oobCode: string;\n  tenantId?: string;\n}\n\nexport interface SignInWithEmailLinkResponse extends IdTokenResponse {\n  email: string;\n  isNewUser: boolean;\n}\n\nexport async function signInWithEmailLink(\n  auth: Auth,\n  request: SignInWithEmailLinkRequest\n): Promise<SignInWithEmailLinkResponse> {\n  return _performSignInRequest<\n    SignInWithEmailLinkRequest,\n    SignInWithEmailLinkResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface SignInWithEmailLinkForLinkingRequest\n  extends SignInWithEmailLinkRequest {\n  idToken: string;\n}\n\nexport async function signInWithEmailLinkForLinking(\n  auth: Auth,\n  request: SignInWithEmailLinkForLinkingRequest\n): Promise<SignInWithEmailLinkResponse> {\n  return _performSignInRequest<\n    SignInWithEmailLinkForLinkingRequest,\n    SignInWithEmailLinkResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { linkEmailPassword } from '../../api/account_management/email_and_password';\nimport {\n  signInWithPassword,\n  SignInWithPasswordRequest\n} from '../../api/authentication/email_and_password';\nimport {\n  signInWithEmailLink,\n  signInWithEmailLinkForLinking\n} from '../../api/authentication/email_link';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from '../util/assert';\nimport { AuthCredential } from './auth_credential';\nimport { handleRecaptchaFlow } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport {\n  RecaptchaActionName,\n  RecaptchaClientType,\n  RecaptchaAuthProvider\n} from '../../api';\nimport { SignUpRequest } from '../../api/authentication/sign_up';\n/**\n * Interface that represents the credentials returned by {@link EmailAuthProvider} for\n * {@link ProviderId}.PASSWORD\n *\n * @remarks\n * Covers both {@link SignInMethod}.EMAIL_PASSWORD and\n * {@link SignInMethod}.EMAIL_LINK.\n *\n * @public\n */\nexport class EmailAuthCredential extends AuthCredential {\n  /** @internal */\n  private constructor(\n    /** @internal */\n    readonly _email: string,\n    /** @internal */\n    readonly _password: string,\n    signInMethod: SignInMethod,\n    /** @internal */\n    readonly _tenantId: string | null = null\n  ) {\n    super(ProviderId.PASSWORD, signInMethod);\n  }\n\n  /** @internal */\n  static _fromEmailAndPassword(\n    email: string,\n    password: string\n  ): EmailAuthCredential {\n    return new EmailAuthCredential(\n      email,\n      password,\n      SignInMethod.EMAIL_PASSWORD\n    );\n  }\n\n  /** @internal */\n  static _fromEmailAndCode(\n    email: string,\n    oobCode: string,\n    tenantId: string | null = null\n  ): EmailAuthCredential {\n    return new EmailAuthCredential(\n      email,\n      oobCode,\n      SignInMethod.EMAIL_LINK,\n      tenantId\n    );\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON} */\n  toJSON(): object {\n    return {\n      email: this._email,\n      password: this._password,\n      signInMethod: this.signInMethod,\n      tenantId: this._tenantId\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an {@link  AuthCredential}.\n   *\n   * @param json - Either `object` or the stringified representation of the object. When string is\n   * provided, `JSON.parse` would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link AuthCredential}, null is returned.\n   */\n  static fromJSON(json: object | string): EmailAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    if (obj?.email && obj?.password) {\n      if (obj.signInMethod === SignInMethod.EMAIL_PASSWORD) {\n        return this._fromEmailAndPassword(obj.email, obj.password);\n      } else if (obj.signInMethod === SignInMethod.EMAIL_LINK) {\n        return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);\n      }\n    }\n    return null;\n  }\n\n  /** @internal */\n  async _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    switch (this.signInMethod) {\n      case SignInMethod.EMAIL_PASSWORD:\n        const request: SignInWithPasswordRequest = {\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password,\n          clientType: RecaptchaClientType.WEB\n        };\n        return handleRecaptchaFlow(\n          auth,\n          request,\n          RecaptchaActionName.SIGN_IN_WITH_PASSWORD,\n          signInWithPassword,\n          RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n        );\n      case SignInMethod.EMAIL_LINK:\n        return signInWithEmailLink(auth, {\n          email: this._email,\n          oobCode: this._password\n        });\n      default:\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  /** @internal */\n  async _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    switch (this.signInMethod) {\n      case SignInMethod.EMAIL_PASSWORD:\n        const request: SignUpRequest = {\n          idToken,\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password,\n          clientType: RecaptchaClientType.WEB\n        };\n        return handleRecaptchaFlow(\n          auth,\n          request,\n          RecaptchaActionName.SIGN_UP_PASSWORD,\n          linkEmailPassword,\n          RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n        );\n      case SignInMethod.EMAIL_LINK:\n        return signInWithEmailLinkForLinking(auth, {\n          idToken,\n          email: this._email,\n          oobCode: this._password\n        });\n      default:\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return this._getIdTokenResponse(auth);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdToken, IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithIdpRequest {\n  requestUri: string;\n  postBody?: string;\n  sessionId?: string;\n  tenantId?: string;\n  returnSecureToken: boolean;\n  returnIdpCredential?: boolean;\n  idToken?: IdToken;\n  autoCreate?: boolean;\n  pendingToken?: string;\n}\n\n/**\n * @internal\n */\nexport interface SignInWithIdpResponse extends IdTokenResponse {\n  oauthAccessToken?: string;\n  oauthTokenSecret?: string;\n  nonce?: string;\n  oauthIdToken?: string;\n  pendingToken?: string;\n}\n\nexport async function signInWithIdp(\n  auth: Auth,\n  request: SignInWithIdpRequest\n): Promise<SignInWithIdpResponse> {\n  return _performSignInRequest<SignInWithIdpRequest, SignInWithIdpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_IDP,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { querystring } from '@firebase/util';\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from '../util/assert';\nimport { AuthCredential } from './auth_credential';\n\nconst IDP_REQUEST_URI = 'http://localhost';\n\nexport interface OAuthCredentialParams {\n  // OAuth 2 uses either id token or access token\n  idToken?: string | null;\n  accessToken?: string | null;\n\n  // These fields are used with OAuth 1\n  oauthToken?: string;\n  secret?: string;\n  oauthTokenSecret?: string;\n\n  // Nonce is only set if pendingToken is not present\n  nonce?: string;\n  pendingToken?: string;\n\n  // Utilities\n  providerId: string;\n  signInMethod: string;\n}\n\n/**\n * Represents the OAuth credentials returned by an {@link OAuthProvider}.\n *\n * @remarks\n * Implementations specify the details about each auth provider's credential requirements.\n *\n * @public\n */\nexport class OAuthCredential extends AuthCredential {\n  /**\n   * The OAuth ID token associated with the credential if it belongs to an OIDC provider,\n   * such as `google.com`.\n   * @readonly\n   */\n  idToken?: string;\n  /**\n   * The OAuth access token associated with the credential if it belongs to an\n   * {@link OAuthProvider}, such as `facebook.com`, `twitter.com`, etc.\n   * @readonly\n   */\n  accessToken?: string;\n  /**\n   * The OAuth access token secret associated with the credential if it belongs to an OAuth 1.0\n   * provider, such as `twitter.com`.\n   * @readonly\n   */\n  secret?: string;\n\n  private nonce?: string;\n  private pendingToken: string | null = null;\n\n  /** @internal */\n  static _fromParams(params: OAuthCredentialParams): OAuthCredential {\n    const cred = new OAuthCredential(params.providerId, params.signInMethod);\n\n    if (params.idToken || params.accessToken) {\n      // OAuth 2 and either ID token or access token.\n      if (params.idToken) {\n        cred.idToken = params.idToken;\n      }\n\n      if (params.accessToken) {\n        cred.accessToken = params.accessToken;\n      }\n\n      // Add nonce if available and no pendingToken is present.\n      if (params.nonce && !params.pendingToken) {\n        cred.nonce = params.nonce;\n      }\n\n      if (params.pendingToken) {\n        cred.pendingToken = params.pendingToken;\n      }\n    } else if (params.oauthToken && params.oauthTokenSecret) {\n      // OAuth 1 and OAuth token with token secret\n      cred.accessToken = params.oauthToken;\n      cred.secret = params.oauthTokenSecret;\n    } else {\n      _fail(AuthErrorCode.ARGUMENT_ERROR);\n    }\n\n    return cred;\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON}  */\n  toJSON(): object {\n    return {\n      idToken: this.idToken,\n      accessToken: this.accessToken,\n      secret: this.secret,\n      nonce: this.nonce,\n      pendingToken: this.pendingToken,\n      providerId: this.providerId,\n      signInMethod: this.signInMethod\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an\n   * {@link  AuthCredential}.\n   *\n   * @param json - Input can be either Object or the stringified representation of the object.\n   * When string is provided, JSON.parse would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.\n   */\n  static fromJSON(json: string | object): OAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    const { providerId, signInMethod, ...rest }: OAuthCredentialParams = obj;\n    if (!providerId || !signInMethod) {\n      return null;\n    }\n\n    const cred = new OAuthCredential(providerId, signInMethod);\n    cred.idToken = rest.idToken || undefined;\n    cred.accessToken = rest.accessToken || undefined;\n    cred.secret = rest.secret;\n    cred.nonce = rest.nonce;\n    cred.pendingToken = rest.pendingToken || null;\n    return cred;\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.idToken = idToken;\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.autoCreate = false;\n    return signInWithIdp(auth, request);\n  }\n\n  private buildRequest(): SignInWithIdpRequest {\n    const request: SignInWithIdpRequest = {\n      requestUri: IDP_REQUEST_URI,\n      returnSecureToken: true\n    };\n\n    if (this.pendingToken) {\n      request.pendingToken = this.pendingToken;\n    } else {\n      const postBody: Record<string, string> = {};\n      if (this.idToken) {\n        postBody['id_token'] = this.idToken;\n      }\n      if (this.accessToken) {\n        postBody['access_token'] = this.accessToken;\n      }\n      if (this.secret) {\n        postBody['oauth_token_secret'] = this.secret;\n      }\n\n      postBody['providerId'] = this.providerId;\n      if (this.nonce && !this.pendingToken) {\n        postBody['nonce'] = this.nonce;\n      }\n\n      request.postBody = querystring(postBody);\n    }\n\n    return request;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _makeTaggedError,\n  _performApiRequest,\n  _performSignInRequest\n} from '../index';\nimport { AuthErrorCode } from '../../core/errors';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { ServerError, ServerErrorMap } from '../errors';\nimport { Auth } from '../../model/public_types';\n\nexport interface SendPhoneVerificationCodeRequest {\n  phoneNumber: string;\n  // reCAPTCHA v2 token\n  recaptchaToken?: string;\n  tenantId?: string;\n  // reCAPTCHA Enterprise token\n  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface SendPhoneVerificationCodeResponse {\n  sessionInfo: string;\n}\n\nexport async function sendPhoneVerificationCode(\n  auth: Auth,\n  request: SendPhoneVerificationCodeRequest\n): Promise<SendPhoneVerificationCodeResponse> {\n  return _performApiRequest<\n    SendPhoneVerificationCodeRequest,\n    SendPhoneVerificationCodeResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SEND_VERIFICATION_CODE,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\n/**\n * @internal\n */\nexport interface SignInWithPhoneNumberRequest {\n  temporaryProof?: string;\n  phoneNumber?: string;\n  sessionInfo?: string;\n  code?: string;\n  tenantId?: string;\n}\n\nexport interface LinkWithPhoneNumberRequest\n  extends SignInWithPhoneNumberRequest {\n  idToken: string;\n}\n\n/**\n * @internal\n */\nexport interface SignInWithPhoneNumberResponse extends IdTokenResponse {\n  temporaryProof?: string;\n  phoneNumber?: string;\n}\n\nexport async function signInWithPhoneNumber(\n  auth: Auth,\n  request: SignInWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  return _performSignInRequest<\n    SignInWithPhoneNumberRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport async function linkWithPhoneNumber(\n  auth: Auth,\n  request: LinkWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  const response = await _performSignInRequest<\n    LinkWithPhoneNumberRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, request)\n  );\n  if (response.temporaryProof) {\n    throw _makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, response);\n  }\n  return response;\n}\n\ninterface VerifyPhoneNumberForExistingRequest\n  extends SignInWithPhoneNumberRequest {\n  operation: 'REAUTH';\n}\n\nconst VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_: Partial<\n  ServerErrorMap<ServerError>\n> = {\n  [ServerError.USER_NOT_FOUND]: AuthErrorCode.USER_DELETED\n};\n\nexport async function verifyPhoneNumberForExisting(\n  auth: Auth,\n  request: SignInWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  const apiRequest: VerifyPhoneNumberForExistingRequest = {\n    ...request,\n    operation: 'REAUTH'\n  };\n  return _performSignInRequest<\n    VerifyPhoneNumberForExistingRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, apiRequest),\n    VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport {\n  linkWithPhoneNumber,\n  signInWithPhoneNumber,\n  SignInWithPhoneNumberRequest,\n  verifyPhoneNumberForExisting\n} from '../../api/authentication/sms';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthCredential } from './auth_credential';\n\nexport interface PhoneAuthCredentialParameters {\n  verificationId?: string;\n  verificationCode?: string;\n  phoneNumber?: string;\n  temporaryProof?: string;\n}\n\n/**\n * Represents the credentials returned by {@link PhoneAuthProvider}.\n *\n * @public\n */\nexport class PhoneAuthCredential extends AuthCredential {\n  private constructor(private readonly params: PhoneAuthCredentialParameters) {\n    super(ProviderId.PHONE, SignInMethod.PHONE);\n  }\n\n  /** @internal */\n  static _fromVerification(\n    verificationId: string,\n    verificationCode: string\n  ): PhoneAuthCredential {\n    return new PhoneAuthCredential({ verificationId, verificationCode });\n  }\n\n  /** @internal */\n  static _fromTokenResponse(\n    phoneNumber: string,\n    temporaryProof: string\n  ): PhoneAuthCredential {\n    return new PhoneAuthCredential({ phoneNumber, temporaryProof });\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return signInWithPhoneNumber(auth, this._makeVerificationRequest());\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    return linkWithPhoneNumber(auth, {\n      idToken,\n      ...this._makeVerificationRequest()\n    });\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return verifyPhoneNumberForExisting(auth, this._makeVerificationRequest());\n  }\n\n  /** @internal */\n  _makeVerificationRequest(): SignInWithPhoneNumberRequest {\n    const { temporaryProof, phoneNumber, verificationId, verificationCode } =\n      this.params;\n    if (temporaryProof && phoneNumber) {\n      return { temporaryProof, phoneNumber };\n    }\n\n    return {\n      sessionInfo: verificationId,\n      code: verificationCode\n    };\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON} */\n  toJSON(): object {\n    const obj: Record<string, string> = {\n      providerId: this.providerId\n    };\n    if (this.params.phoneNumber) {\n      obj.phoneNumber = this.params.phoneNumber;\n    }\n    if (this.params.temporaryProof) {\n      obj.temporaryProof = this.params.temporaryProof;\n    }\n    if (this.params.verificationCode) {\n      obj.verificationCode = this.params.verificationCode;\n    }\n    if (this.params.verificationId) {\n      obj.verificationId = this.params.verificationId;\n    }\n\n    return obj;\n  }\n\n  /** Generates a phone credential based on a plain object or a JSON string. */\n  static fromJSON(json: object | string): PhoneAuthCredential | null {\n    if (typeof json === 'string') {\n      json = JSON.parse(json);\n    }\n\n    const { verificationId, verificationCode, phoneNumber, temporaryProof } =\n      json as { [key: string]: string };\n    if (\n      !verificationCode &&\n      !verificationId &&\n      !phoneNumber &&\n      !temporaryProof\n    ) {\n      return null;\n    }\n\n    return new PhoneAuthCredential({\n      verificationId,\n      verificationCode,\n      phoneNumber,\n      temporaryProof\n    });\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { extractQuerystring, querystringDecode } from '@firebase/util';\nimport { ActionCodeOperation } from '../model/public_types';\nimport { AuthErrorCode } from './errors';\nimport { _assert } from './util/assert';\n\n/**\n * Enums for fields in URL query string.\n *\n * @enum {string}\n */\nconst enum QueryField {\n  API_KEY = 'apiKey',\n  CODE = 'oobCode',\n  CONTINUE_URL = 'continueUrl',\n  LANGUAGE_CODE = 'lang',\n  MODE = 'mode',\n  TENANT_ID = 'tenantId'\n}\n\n/**\n * Maps the mode string in action code URL to Action Code Info operation.\n *\n * @param mode\n */\nfunction parseMode(mode: string | null): ActionCodeOperation | null {\n  switch (mode) {\n    case 'recoverEmail':\n      return ActionCodeOperation.RECOVER_EMAIL;\n    case 'resetPassword':\n      return ActionCodeOperation.PASSWORD_RESET;\n    case 'signIn':\n      return ActionCodeOperation.EMAIL_SIGNIN;\n    case 'verifyEmail':\n      return ActionCodeOperation.VERIFY_EMAIL;\n    case 'verifyAndChangeEmail':\n      return ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;\n    case 'revertSecondFactorAddition':\n      return ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION;\n    default:\n      return null;\n  }\n}\n\n/**\n * Helper to parse FDL links\n *\n * @param url\n */\nfunction parseDeepLink(url: string): string {\n  const link = querystringDecode(extractQuerystring(url))['link'];\n\n  // Double link case (automatic redirect).\n  const doubleDeepLink = link\n    ? querystringDecode(extractQuerystring(link))['deep_link_id']\n    : null;\n  // iOS custom scheme links.\n  const iOSDeepLink = querystringDecode(extractQuerystring(url))[\n    'deep_link_id'\n  ];\n  const iOSDoubleDeepLink = iOSDeepLink\n    ? querystringDecode(extractQuerystring(iOSDeepLink))['link']\n    : null;\n  return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;\n}\n\n/**\n * A utility class to parse email action URLs such as password reset, email verification,\n * email link sign in, etc.\n *\n * @public\n */\nexport class ActionCodeURL {\n  /**\n   * The API key of the email action link.\n   */\n  readonly apiKey: string;\n  /**\n   * The action code of the email action link.\n   */\n  readonly code: string;\n  /**\n   * The continue URL of the email action link. Null if not provided.\n   */\n  readonly continueUrl: string | null;\n  /**\n   * The language code of the email action link. Null if not provided.\n   */\n  readonly languageCode: string | null;\n  /**\n   * The action performed by the email action link. It returns from one of the types from\n   * {@link ActionCodeInfo}\n   */\n  readonly operation: string;\n  /**\n   * The tenant ID of the email action link. Null if the email action is from the parent project.\n   */\n  readonly tenantId: string | null;\n\n  /**\n   * @param actionLink - The link from which to extract the URL.\n   * @returns The {@link ActionCodeURL} object, or null if the link is invalid.\n   *\n   * @internal\n   */\n  constructor(actionLink: string) {\n    const searchParams = querystringDecode(extractQuerystring(actionLink));\n    const apiKey = searchParams[QueryField.API_KEY] ?? null;\n    const code = searchParams[QueryField.CODE] ?? null;\n    const operation = parseMode(searchParams[QueryField.MODE] ?? null);\n    // Validate API key, code and mode.\n    _assert(apiKey && code && operation, AuthErrorCode.ARGUMENT_ERROR);\n    this.apiKey = apiKey;\n    this.operation = operation;\n    this.code = code;\n    this.continueUrl = searchParams[QueryField.CONTINUE_URL] ?? null;\n    this.languageCode = searchParams[QueryField.LANGUAGE_CODE] ?? null;\n    this.tenantId = searchParams[QueryField.TENANT_ID] ?? null;\n  }\n\n  /**\n   * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,\n   * otherwise returns null.\n   *\n   * @param link  - The email action link string.\n   * @returns The {@link ActionCodeURL} object, or null if the link is invalid.\n   *\n   * @public\n   */\n  static parseLink(link: string): ActionCodeURL | null {\n    const actionLink = parseDeepLink(link);\n    try {\n      return new ActionCodeURL(actionLink);\n    } catch {\n      return null;\n    }\n  }\n}\n\n/**\n * Parses the email action link string and returns an {@link ActionCodeURL} if\n * the link is valid, otherwise returns null.\n *\n * @public\n */\nexport function parseActionCodeURL(link: string): ActionCodeURL | null {\n  return ActionCodeURL.parseLink(link);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\nimport { AuthProvider } from '../../model/public_types';\n\nimport { ActionCodeURL } from '../action_code_url';\nimport { EmailAuthCredential } from '../credentials/email';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\n\n/**\n * Provider for generating {@link EmailAuthCredential}.\n *\n * @public\n */\nexport class EmailAuthProvider implements AuthProvider {\n  /**\n   * Always set to {@link ProviderId}.PASSWORD, even for email link.\n   */\n  static readonly PROVIDER_ID: 'password' = ProviderId.PASSWORD;\n  /**\n   * Always set to {@link SignInMethod}.EMAIL_PASSWORD.\n   */\n  static readonly EMAIL_PASSWORD_SIGN_IN_METHOD: 'password' =\n    SignInMethod.EMAIL_PASSWORD;\n  /**\n   * Always set to {@link SignInMethod}.EMAIL_LINK.\n   */\n  static readonly EMAIL_LINK_SIGN_IN_METHOD: 'emailLink' =\n    SignInMethod.EMAIL_LINK;\n  /**\n   * Always set to {@link ProviderId}.PASSWORD, even for email link.\n   */\n  readonly providerId = EmailAuthProvider.PROVIDER_ID;\n\n  /**\n   * Initialize an {@link AuthCredential} using an email and password.\n   *\n   * @example\n   * ```javascript\n   * const authCredential = EmailAuthProvider.credential(email, password);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * ```javascript\n   * const userCredential = await signInWithEmailAndPassword(auth, email, password);\n   * ```\n   *\n   * @param email - Email address.\n   * @param password - User account password.\n   * @returns The auth provider credential.\n   */\n  static credential(email: string, password: string): EmailAuthCredential {\n    return EmailAuthCredential._fromEmailAndPassword(email, password);\n  }\n\n  /**\n   * Initialize an {@link AuthCredential} using an email and an email link after a sign in with\n   * email link operation.\n   *\n   * @example\n   * ```javascript\n   * const authCredential = EmailAuthProvider.credentialWithLink(auth, email, emailLink);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * ```javascript\n   * await sendSignInLinkToEmail(auth, email);\n   * // Obtain emailLink from user.\n   * const userCredential = await signInWithEmailLink(auth, email, emailLink);\n   * ```\n   *\n   * @param auth - The {@link Auth} instance used to verify the link.\n   * @param email - Email address.\n   * @param emailLink - Sign-in email link.\n   * @returns - The auth provider credential.\n   */\n  static credentialWithLink(\n    email: string,\n    emailLink: string\n  ): EmailAuthCredential {\n    const actionCodeUrl = ActionCodeURL.parseLink(emailLink);\n    _assert(actionCodeUrl, AuthErrorCode.ARGUMENT_ERROR);\n\n    return EmailAuthCredential._fromEmailAndCode(\n      email,\n      actionCodeUrl.code,\n      actionCodeUrl.tenantId\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider } from '../../model/public_types';\n\n/**\n * Map of OAuth Custom Parameters.\n *\n * @public\n */\nexport type CustomParameters = Record<string, string>;\n\n/**\n * The base class for all Federated providers (OAuth (including OIDC), SAML).\n *\n * This class is not meant to be instantiated directly.\n *\n * @public\n */\nexport abstract class FederatedAuthProvider implements AuthProvider {\n  /** @internal */\n  defaultLanguageCode: string | null = null;\n  /** @internal */\n  private customParameters: CustomParameters = {};\n\n  /**\n   * Constructor for generic OAuth providers.\n   *\n   * @param providerId - Provider for which credentials should be generated.\n   */\n  constructor(readonly providerId: string) {}\n\n  /**\n   * Set the language gode.\n   *\n   * @param languageCode - language code\n   */\n  setDefaultLanguage(languageCode: string | null): void {\n    this.defaultLanguageCode = languageCode;\n  }\n\n  /**\n   * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in\n   * operations.\n   *\n   * @remarks\n   * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,\n   * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.\n   *\n   * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.\n   */\n  setCustomParameters(customOAuthParameters: CustomParameters): AuthProvider {\n    this.customParameters = customOAuthParameters;\n    return this;\n  }\n\n  /**\n   * Retrieve the current list of {@link CustomParameters}.\n   */\n  getCustomParameters(): CustomParameters {\n    return this.customParameters;\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider, UserCredential } from '../../model/public_types';\n\nimport { _assert } from '../util/assert';\nimport { AuthErrorCode } from '../errors';\n\nimport { OAuthCredential, OAuthCredentialParams } from '../credentials/oauth';\nimport { UserCredentialInternal } from '../../model/user';\nimport { FirebaseError } from '@firebase/util';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { SignInWithIdpResponse } from '../../../internal';\nimport { FederatedAuthProvider } from './federated';\n\n/**\n * Defines the options for initializing an {@link OAuthCredential}.\n *\n * @remarks\n * For ID tokens with nonce claim, the raw nonce has to also be provided.\n *\n * @public\n */\nexport interface OAuthCredentialOptions {\n  /**\n   * The OAuth ID token used to initialize the {@link OAuthCredential}.\n   */\n  idToken?: string;\n  /**\n   * The OAuth access token used to initialize the {@link OAuthCredential}.\n   */\n  accessToken?: string;\n  /**\n   * The raw nonce associated with the ID token.\n   *\n   * @remarks\n   * It is required when an ID token with a nonce field is provided. The SHA-256 hash of the\n   * raw nonce must match the nonce field in the ID token.\n   */\n  rawNonce?: string;\n}\n\n/**\n * Common code to all OAuth providers. This is separate from the\n * {@link OAuthProvider} so that child providers (like\n * {@link GoogleAuthProvider}) don't inherit the `credential` instance method.\n * Instead, they rely on a static `credential` method.\n */\nexport abstract class BaseOAuthProvider\n  extends FederatedAuthProvider\n  implements AuthProvider\n{\n  /** @internal */\n  private scopes: string[] = [];\n\n  /**\n   * Add an OAuth scope to the credential.\n   *\n   * @param scope - Provider OAuth scope to add.\n   */\n  addScope(scope: string): AuthProvider {\n    // If not already added, add scope to list.\n    if (!this.scopes.includes(scope)) {\n      this.scopes.push(scope);\n    }\n    return this;\n  }\n\n  /**\n   * Retrieve the current list of OAuth scopes.\n   */\n  getScopes(): string[] {\n    return [...this.scopes];\n  }\n}\n\n/**\n * Provider for generating generic {@link OAuthCredential}.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new OAuthProvider('google.com');\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('profile');\n * provider.addScope('email');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a OAuth Access Token for the provider.\n *   const credential = provider.credentialFromResult(auth, result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new OAuthProvider('google.com');\n * provider.addScope('profile');\n * provider.addScope('email');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a OAuth Access Token for the provider.\n * const credential = provider.credentialFromResult(auth, result);\n * const token = credential.accessToken;\n * ```\n * @public\n */\nexport class OAuthProvider extends BaseOAuthProvider {\n  /**\n   * Creates an {@link OAuthCredential} from a JSON string or a plain object.\n   * @param json - A plain object or a JSON string\n   */\n  static credentialFromJSON(json: object | string): OAuthCredential {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    _assert(\n      'providerId' in obj && 'signInMethod' in obj,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    return OAuthCredential._fromParams(obj);\n  }\n\n  /**\n   * Creates a {@link OAuthCredential} from a generic OAuth provider's access token or ID token.\n   *\n   * @remarks\n   * The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of\n   * the raw nonce must match the nonce field in the ID token.\n   *\n   * @example\n   * ```javascript\n   * // `googleUser` from the onsuccess Google Sign In callback.\n   * // Initialize a generate OAuth provider with a `google.com` providerId.\n   * const provider = new OAuthProvider('google.com');\n   * const credential = provider.credential({\n   *   idToken: googleUser.getAuthResponse().id_token,\n   * });\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param params - Either the options object containing the ID token, access token and raw nonce\n   * or the ID token string.\n   */\n  credential(params: OAuthCredentialOptions): OAuthCredential {\n    return this._credential({ ...params, nonce: params.rawNonce });\n  }\n\n  /** An internal credential method that accepts more permissive options */\n  private _credential(\n    params: Omit<OAuthCredentialParams, 'signInMethod' | 'providerId'>\n  ): OAuthCredential {\n    _assert(params.idToken || params.accessToken, AuthErrorCode.ARGUMENT_ERROR);\n    // For OAuthCredential, sign in method is same as providerId.\n    return OAuthCredential._fromParams({\n      ...params,\n      providerId: this.providerId,\n      signInMethod: this.providerId\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return OAuthProvider.oauthCredentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return OAuthProvider.oauthCredentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static oauthCredentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const {\n      oauthIdToken,\n      oauthAccessToken,\n      oauthTokenSecret,\n      pendingToken,\n      nonce,\n      providerId\n    } = tokenResponse as SignInWithIdpResponse;\n    if (\n      !oauthAccessToken &&\n      !oauthTokenSecret &&\n      !oauthIdToken &&\n      !pendingToken\n    ) {\n      return null;\n    }\n\n    if (!providerId) {\n      return null;\n    }\n\n    try {\n      return new OAuthProvider(providerId)._credential({\n        idToken: oauthIdToken,\n        accessToken: oauthAccessToken,\n        nonce,\n        pendingToken\n      });\n    } catch (e) {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.FACEBOOK.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new FacebookAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('user_birthday');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Facebook Access Token.\n *   const credential = FacebookAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new FacebookAuthProvider();\n * provider.addScope('user_birthday');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Facebook Access Token.\n * const credential = FacebookAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n *\n * @public\n */\nexport class FacebookAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.FACEBOOK. */\n  static readonly FACEBOOK_SIGN_IN_METHOD: 'facebook.com' =\n    SignInMethod.FACEBOOK;\n  /** Always set to {@link ProviderId}.FACEBOOK. */\n  static readonly PROVIDER_ID: 'facebook.com' = ProviderId.FACEBOOK;\n\n  constructor() {\n    super(ProviderId.FACEBOOK);\n  }\n\n  /**\n   * Creates a credential for Facebook.\n   *\n   * @example\n   * ```javascript\n   * // `event` from the Facebook auth.authResponseChange callback.\n   * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param accessToken - Facebook access token.\n   */\n  static credential(accessToken: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: FacebookAuthProvider.PROVIDER_ID,\n      signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return FacebookAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return FacebookAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {\n      return null;\n    }\n\n    if (!tokenResponse.oauthAccessToken) {\n      return null;\n    }\n\n    try {\n      return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GOOGLE.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new GoogleAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('profile');\n * provider.addScope('email');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Google Access Token.\n *   const credential = GoogleAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new GoogleAuthProvider();\n * provider.addScope('profile');\n * provider.addScope('email');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Google Access Token.\n * const credential = GoogleAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n *\n * @public\n */\nexport class GoogleAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.GOOGLE. */\n  static readonly GOOGLE_SIGN_IN_METHOD: 'google.com' = SignInMethod.GOOGLE;\n  /** Always set to {@link ProviderId}.GOOGLE. */\n  static readonly PROVIDER_ID: 'google.com' = ProviderId.GOOGLE;\n\n  constructor() {\n    super(ProviderId.GOOGLE);\n    this.addScope('profile');\n  }\n\n  /**\n   * Creates a credential for Google. At least one of ID token and access token is required.\n   *\n   * @example\n   * ```javascript\n   * // \\`googleUser\\` from the onsuccess Google Sign In callback.\n   * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param idToken - Google ID token.\n   * @param accessToken - Google access token.\n   */\n  static credential(\n    idToken?: string | null,\n    accessToken?: string | null\n  ): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: GoogleAuthProvider.PROVIDER_ID,\n      signInMethod: GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,\n      idToken,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return GoogleAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return GoogleAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const { oauthIdToken, oauthAccessToken } =\n      tokenResponse as SignInWithIdpResponse;\n    if (!oauthIdToken && !oauthAccessToken) {\n      // This could be an oauth 1 credential or a phone credential\n      return null;\n    }\n\n    try {\n      return GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GITHUB.\n *\n * @remarks\n * GitHub requires an OAuth 2.0 redirect, so you can either handle the redirect directly, or use\n * the {@link signInWithPopup} handler:\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new GithubAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('repo');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a GitHub Access Token.\n *   const credential = GithubAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new GithubAuthProvider();\n * provider.addScope('repo');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a GitHub Access Token.\n * const credential = GithubAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n * @public\n */\nexport class GithubAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.GITHUB. */\n  static readonly GITHUB_SIGN_IN_METHOD: 'github.com' = SignInMethod.GITHUB;\n  /** Always set to {@link ProviderId}.GITHUB. */\n  static readonly PROVIDER_ID: 'github.com' = ProviderId.GITHUB;\n\n  constructor() {\n    super(ProviderId.GITHUB);\n  }\n\n  /**\n   * Creates a credential for GitHub.\n   *\n   * @param accessToken - GitHub access token.\n   */\n  static credential(accessToken: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: GithubAuthProvider.PROVIDER_ID,\n      signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return GithubAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return GithubAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {\n      return null;\n    }\n\n    if (!tokenResponse.oauthAccessToken) {\n      return null;\n    }\n\n    try {\n      return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Represents the SAML credentials returned by an {@link SAMLAuthProvider}.\n *\n * @public\n */\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthCredential } from './auth_credential';\n\nconst IDP_REQUEST_URI = 'http://localhost';\n\n/**\n * @public\n */\nexport class SAMLAuthCredential extends AuthCredential {\n  /** @internal */\n  private constructor(\n    providerId: string,\n    private readonly pendingToken: string\n  ) {\n    super(providerId, providerId);\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.idToken = idToken;\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.autoCreate = false;\n    return signInWithIdp(auth, request);\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON}  */\n  toJSON(): object {\n    return {\n      signInMethod: this.signInMethod,\n      providerId: this.providerId,\n      pendingToken: this.pendingToken\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an\n   * {@link  AuthCredential}.\n   *\n   * @param json - Input can be either Object or the stringified representation of the object.\n   * When string is provided, JSON.parse would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.\n   */\n  static fromJSON(json: string | object): SAMLAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    const { providerId, signInMethod, pendingToken }: Record<string, string> =\n      obj;\n    if (\n      !providerId ||\n      !signInMethod ||\n      !pendingToken ||\n      providerId !== signInMethod\n    ) {\n      return null;\n    }\n\n    return new SAMLAuthCredential(providerId, pendingToken);\n  }\n\n  /**\n   * Helper static method to avoid exposing the constructor to end users.\n   *\n   * @internal\n   */\n  static _create(providerId: string, pendingToken: string): SAMLAuthCredential {\n    return new SAMLAuthCredential(providerId, pendingToken);\n  }\n\n  private buildRequest(): SignInWithIdpRequest {\n    return {\n      requestUri: IDP_REQUEST_URI,\n      returnSecureToken: true,\n      pendingToken: this.pendingToken\n    };\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredential } from '../../model/public_types';\nimport { UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { SAMLAuthCredential } from '../credentials/saml';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { FederatedAuthProvider } from './federated';\n\nconst SAML_PROVIDER_PREFIX = 'saml.';\n\n/**\n * An {@link AuthProvider} for SAML.\n *\n * @public\n */\nexport class SAMLAuthProvider extends FederatedAuthProvider {\n  /**\n   * Constructor. The providerId must start with \"saml.\"\n   * @param providerId - SAML provider ID.\n   */\n  constructor(providerId: string) {\n    _assert(\n      providerId.startsWith(SAML_PROVIDER_PREFIX),\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    super(providerId);\n  }\n\n  /**\n   * Generates an {@link AuthCredential} from a {@link UserCredential} after a\n   * successful SAML flow completes.\n   *\n   * @remarks\n   *\n   * For example, to get an {@link AuthCredential}, you could write the\n   * following code:\n   *\n   * ```js\n   * const userCredential = await signInWithPopup(auth, samlProvider);\n   * const credential = SAMLAuthProvider.credentialFromResult(userCredential);\n   * ```\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): AuthCredential | null {\n    return SAMLAuthProvider.samlCredentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): AuthCredential | null {\n    return SAMLAuthProvider.samlCredentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  /**\n   * Creates an {@link AuthCredential} from a JSON string or a plain object.\n   * @param json - A plain object or a JSON string\n   */\n  static credentialFromJSON(json: string | object): AuthCredential {\n    const credential = SAMLAuthCredential.fromJSON(json);\n    _assert(credential, AuthErrorCode.ARGUMENT_ERROR);\n    return credential;\n  }\n\n  private static samlCredentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): SAMLAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const { pendingToken, providerId } = tokenResponse as SignInWithIdpResponse;\n\n    if (!pendingToken || !providerId) {\n      return null;\n    }\n\n    try {\n      return SAMLAuthCredential._create(providerId, pendingToken);\n    } catch (e) {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @license\n * Copyright 2020 Twitter LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.TWITTER.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new TwitterAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Twitter Access Token and Secret.\n *   const credential = TwitterAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n *   const secret = credential.secret;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new TwitterAuthProvider();\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Twitter Access Token and Secret.\n * const credential = TwitterAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * const secret = credential.secret;\n * ```\n *\n * @public\n */\nexport class TwitterAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.TWITTER. */\n  static readonly TWITTER_SIGN_IN_METHOD: 'twitter.com' = SignInMethod.TWITTER;\n  /** Always set to {@link ProviderId}.TWITTER. */\n  static readonly PROVIDER_ID: 'twitter.com' = ProviderId.TWITTER;\n\n  constructor() {\n    super(ProviderId.TWITTER);\n  }\n\n  /**\n   * Creates a credential for Twitter.\n   *\n   * @param token - Twitter access token.\n   * @param secret - Twitter secret.\n   */\n  static credential(token: string, secret: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: TwitterAuthProvider.PROVIDER_ID,\n      signInMethod: TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,\n      oauthToken: token,\n      oauthTokenSecret: secret\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return TwitterAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return TwitterAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n    const { oauthAccessToken, oauthTokenSecret } =\n      tokenResponse as SignInWithIdpResponse;\n    if (!oauthAccessToken || !oauthTokenSecret) {\n      return null;\n    }\n\n    try {\n      return TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignUpRequest {\n  idToken?: string;\n  returnSecureToken?: boolean;\n  email?: string;\n  password?: string;\n  tenantId?: string;\n  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface SignUpResponse extends IdTokenResponse {\n  displayName?: string;\n  email?: string;\n}\n\nexport async function signUp(\n  auth: Auth,\n  request: SignUpRequest\n): Promise<SignUpResponse> {\n  return _performSignInRequest<SignUpRequest, SignUpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_UP,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { UserImpl } from './user_impl';\nimport { AuthInternal } from '../../model/auth';\nimport { OperationType, ProviderId } from '../../model/enums';\n\ninterface UserCredentialParams {\n  readonly user: UserInternal;\n  readonly providerId: ProviderId | string | null;\n  readonly _tokenResponse?: PhoneOrOauthTokenResponse;\n  readonly operationType: OperationType;\n}\n\nexport class UserCredentialImpl\n  implements UserCredentialInternal, UserCredentialParams\n{\n  readonly user: UserInternal;\n  readonly providerId: ProviderId | string | null;\n  readonly _tokenResponse: PhoneOrOauthTokenResponse | undefined;\n  readonly operationType: OperationType;\n\n  constructor(params: UserCredentialParams) {\n    this.user = params.user;\n    this.providerId = params.providerId;\n    this._tokenResponse = params._tokenResponse;\n    this.operationType = params.operationType;\n  }\n\n  static async _fromIdTokenResponse(\n    auth: AuthInternal,\n    operationType: OperationType,\n    idTokenResponse: IdTokenResponse,\n    isAnonymous: boolean = false\n  ): Promise<UserCredentialInternal> {\n    const user = await UserImpl._fromIdTokenResponse(\n      auth,\n      idTokenResponse,\n      isAnonymous\n    );\n    const providerId = providerIdForResponse(idTokenResponse);\n    const userCred = new UserCredentialImpl({\n      user,\n      providerId,\n      _tokenResponse: idTokenResponse,\n      operationType\n    });\n    return userCred;\n  }\n\n  static async _forOperation(\n    user: UserInternal,\n    operationType: OperationType,\n    response: PhoneOrOauthTokenResponse\n  ): Promise<UserCredentialImpl> {\n    await user._updateTokensIfNecessary(response, /* reload */ true);\n    const providerId = providerIdForResponse(response);\n    return new UserCredentialImpl({\n      user,\n      providerId,\n      _tokenResponse: response,\n      operationType\n    });\n  }\n}\n\nfunction providerIdForResponse(\n  response: IdTokenResponse\n): ProviderId | string | null {\n  if (response.providerId) {\n    return response.providerId;\n  }\n\n  if ('phoneNumber' in response) {\n    return ProviderId.PHONE;\n  }\n\n  return null;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, UserCredential } from '../../model/public_types';\nimport { signUp } from '../../api/authentication/sign_up';\nimport { UserInternal } from '../../model/user';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { OperationType } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\n/**\n * Asynchronously signs in as an anonymous user.\n *\n * @remarks\n * If there is already an anonymous user signed in, that user will be returned; otherwise, a\n * new anonymous user identity will be created and returned.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport async function signInAnonymously(auth: Auth): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authInternal = _castAuth(auth);\n  await authInternal._initializationPromise;\n  if (authInternal.currentUser?.isAnonymous) {\n    // If an anonymous user is already signed in, no need to sign them in again.\n    return new UserCredentialImpl({\n      user: authInternal.currentUser as UserInternal,\n      providerId: null,\n      operationType: OperationType.SIGN_IN\n    });\n  }\n  const response = await signUp(authInternal, {\n    returnSecureToken: true\n  });\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response,\n    true\n  );\n  await authInternal._updateCurrentUser(userCredential.user);\n  return userCredential;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { MultiFactorError as MultiFactorErrorPublic } from '../model/public_types';\nimport { FirebaseError } from '@firebase/util';\nimport { AuthInternal } from '../model/auth';\nimport { IdTokenResponse } from '../model/id_token';\nimport { AuthErrorCode } from '../core/errors';\nimport { UserInternal } from '../model/user';\nimport { AuthCredential } from '../core/credentials';\nimport { IdTokenMfaResponse } from '../api/authentication/mfa';\nimport { OperationType } from '../model/enums';\n\nexport type MultiFactorErrorData = MultiFactorErrorPublic['customData'] & {\n  _serverResponse: IdTokenMfaResponse;\n};\n\nexport class MultiFactorError\n  extends FirebaseError\n  implements MultiFactorErrorPublic\n{\n  readonly customData: MultiFactorErrorData;\n\n  private constructor(\n    auth: AuthInternal,\n    error: FirebaseError,\n    readonly operationType: OperationType,\n    readonly user?: UserInternal\n  ) {\n    super(error.code, error.message);\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    Object.setPrototypeOf(this, MultiFactorError.prototype);\n    this.customData = {\n      appName: auth.name,\n      tenantId: auth.tenantId ?? undefined,\n      _serverResponse: error.customData!._serverResponse as IdTokenMfaResponse,\n      operationType\n    };\n  }\n\n  static _fromErrorAndOperation(\n    auth: AuthInternal,\n    error: FirebaseError,\n    operationType: OperationType,\n    user?: UserInternal\n  ): MultiFactorError {\n    return new MultiFactorError(auth, error, operationType, user);\n  }\n}\n\nexport function _processCredentialSavingMfaContextIfNecessary(\n  auth: AuthInternal,\n  operationType: OperationType,\n  credential: AuthCredential,\n  user?: UserInternal\n): Promise<IdTokenResponse> {\n  const idTokenProvider =\n    operationType === OperationType.REAUTHENTICATE\n      ? credential._getReauthenticationResolver(auth)\n      : credential._getIdTokenResponse(auth);\n\n  return idTokenProvider.catch(error => {\n    if (error.code === `auth/${AuthErrorCode.MFA_REQUIRED}`) {\n      throw MultiFactorError._fromErrorAndOperation(\n        auth,\n        error,\n        operationType,\n        user\n      );\n    }\n\n    throw error;\n  });\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface ProviderAssociatedObject {\n  providerId?: string;\n}\n\n/**\n * Takes a set of UserInfo provider data and converts it to a set of names\n */\nexport function providerDataAsNames<T extends ProviderAssociatedObject>(\n  providerData: T[]\n): Set<string> {\n  return new Set(\n    providerData\n      .map(({ providerId }) => providerId)\n      .filter(pid => !!pid) as string[]\n  );\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User } from '../../model/public_types';\n\nimport { deleteLinkedAccounts } from '../../api/account_management/account';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { providerDataAsNames } from '../util/providers';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { _reloadWithoutSaving } from './reload';\nimport { UserCredentialImpl } from './user_credential_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType, ProviderId } from '../../model/enums';\n\n/**\n * Unlinks a provider from a user account.\n *\n * @param user - The user.\n * @param providerId - The provider to unlink.\n *\n * @public\n */\nexport async function unlink(user: User, providerId: string): Promise<User> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  await _assertLinkedStatus(true, userInternal, providerId);\n  const { providerUserInfo } = await deleteLinkedAccounts(userInternal.auth, {\n    idToken: await userInternal.getIdToken(),\n    deleteProvider: [providerId]\n  });\n\n  const providersLeft = providerDataAsNames(providerUserInfo || []);\n\n  userInternal.providerData = userInternal.providerData.filter(pd =>\n    providersLeft.has(pd.providerId)\n  );\n  if (!providersLeft.has(ProviderId.PHONE)) {\n    userInternal.phoneNumber = null;\n  }\n\n  await userInternal.auth._persistUserIfCurrent(userInternal);\n  return userInternal;\n}\n\nexport async function _link(\n  user: UserInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredentialInternal> {\n  const response = await _logoutIfInvalidated(\n    user,\n    credential._linkToIdToken(user.auth, await user.getIdToken()),\n    bypassAuthState\n  );\n  return UserCredentialImpl._forOperation(user, OperationType.LINK, response);\n}\n\nexport async function _assertLinkedStatus(\n  expected: boolean,\n  user: UserInternal,\n  provider: string\n): Promise<void> {\n  await _reloadWithoutSaving(user);\n  const providerIds = providerDataAsNames(user.providerData);\n\n  const code =\n    expected === false\n      ? AuthErrorCode.PROVIDER_ALREADY_LINKED\n      : AuthErrorCode.NO_SUCH_PROVIDER;\n  _assert(providerIds.has(provider) === expected, user.auth, code);\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';\nimport { OperationType } from '../../model/enums';\nimport { UserInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { AuthErrorCode } from '../errors';\nimport { _assert, _fail } from '../util/assert';\nimport { _parseToken } from './id_token_result';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { UserCredentialImpl } from './user_credential_impl';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\nexport async function _reauthenticate(\n  user: UserInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredentialImpl> {\n  const { auth } = user;\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const operationType = OperationType.REAUTHENTICATE;\n\n  try {\n    const response = await _logoutIfInvalidated(\n      user,\n      _processCredentialSavingMfaContextIfNecessary(\n        auth,\n        operationType,\n        credential,\n        user\n      ),\n      bypassAuthState\n    );\n    _assert(response.idToken, auth, AuthErrorCode.INTERNAL_ERROR);\n    const parsed = _parseToken(response.idToken);\n    _assert(parsed, auth, AuthErrorCode.INTERNAL_ERROR);\n\n    const { sub: localId } = parsed;\n    _assert(user.uid === localId, auth, AuthErrorCode.USER_MISMATCH);\n\n    return UserCredentialImpl._forOperation(user, operationType, response);\n  } catch (e) {\n    // Convert user deleted error into user mismatch\n    if ((e as FirebaseError)?.code === `auth/${AuthErrorCode.USER_DELETED}`) {\n      _fail(auth, AuthErrorCode.USER_MISMATCH);\n    }\n    throw e;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential, Auth, User } from '../../model/public_types';\n\nimport { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';\nimport { AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { _assertLinkedStatus, _link } from '../user/link_unlink';\nimport { _reauthenticate } from '../user/reauthenticate';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\nexport async function _signInWithCredential(\n  auth: AuthInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const operationType = OperationType.SIGN_IN;\n  const response = await _processCredentialSavingMfaContextIfNecessary(\n    auth,\n    operationType,\n    credential\n  );\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    auth,\n    operationType,\n    response\n  );\n\n  if (!bypassAuthState) {\n    await auth._updateCurrentUser(userCredential.user);\n  }\n  return userCredential;\n}\n\n/**\n * Asynchronously signs in with the given credentials.\n *\n * @remarks\n * An {@link AuthProvider} can be used to generate the credential.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function signInWithCredential(\n  auth: Auth,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  return _signInWithCredential(_castAuth(auth), credential);\n}\n\n/**\n * Links the user account with the given credentials.\n *\n * @remarks\n * An {@link AuthProvider} can be used to generate the credential.\n *\n * @param user - The user.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function linkWithCredential(\n  user: User,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  const userInternal = getModularInstance(user) as UserInternal;\n\n  await _assertLinkedStatus(false, userInternal, credential.providerId);\n\n  return _link(userInternal, credential);\n}\n\n/**\n * Re-authenticates a user using a fresh credential.\n *\n * @remarks\n * Use before operations such as {@link updatePassword} that require tokens from recent sign-in\n * attempts. This method can be used to recover from a `CREDENTIAL_TOO_OLD_LOGIN_AGAIN` error\n * or a `TOKEN_EXPIRED` error.\n *\n * This method is not supported on any {@link User} signed in by {@link Auth} instances\n * created with a {@link @firebase/app#FirebaseServerApp}.\n *\n * @param user - The user.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function reauthenticateWithCredential(\n  user: User,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  return _reauthenticate(getModularInstance(user) as UserInternal, credential);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithCustomTokenRequest {\n  token: string;\n  returnSecureToken: boolean;\n  tenantId?: string;\n}\n\nexport interface SignInWithCustomTokenResponse extends IdTokenResponse {}\n\nexport async function signInWithCustomToken(\n  auth: Auth,\n  request: SignInWithCustomTokenRequest\n): Promise<SignInWithCustomTokenResponse> {\n  return _performSignInRequest<\n    SignInWithCustomTokenRequest,\n    SignInWithCustomTokenResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_CUSTOM_TOKEN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, UserCredential } from '../../model/public_types';\n\nimport { signInWithCustomToken as getIdTokenResponse } from '../../api/authentication/custom_token';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { OperationType } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n/**\n * Asynchronously signs in using a custom token.\n *\n * @remarks\n * Custom tokens are used to integrate Firebase Auth with existing auth systems, and must\n * be generated by an auth backend using the\n * {@link https://firebase.google.com/docs/reference/admin/node/admin.auth.Auth#createcustomtoken | createCustomToken}\n * method in the {@link https://firebase.google.com/docs/auth/admin | Admin SDK} .\n *\n * Fails with an error if the token is invalid, expired, or not accepted by the Firebase Auth service.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n * @param customToken - The custom token to sign in with.\n *\n * @public\n */\nexport async function signInWithCustomToken(\n  auth: Auth,\n  customToken: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authInternal = _castAuth(auth);\n  const response: IdTokenResponse = await getIdTokenResponse(authInternal, {\n    token: customToken,\n    returnSecureToken: true\n  });\n  const cred = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response\n  );\n  await authInternal._updateCurrentUser(cred.user);\n  return cred;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FactorId,\n  MultiFactorInfo,\n  PhoneMultiFactorInfo,\n  TotpMultiFactorInfo\n} from '../model/public_types';\nimport {\n  PhoneMfaEnrollment,\n  MfaEnrollment,\n  TotpMfaEnrollment\n} from '../api/account_management/mfa';\nimport { AuthErrorCode } from '../core/errors';\nimport { _fail } from '../core/util/assert';\nimport { AuthInternal } from '../model/auth';\n\nexport abstract class MultiFactorInfoImpl implements MultiFactorInfo {\n  readonly uid: string;\n  readonly displayName?: string | null;\n  readonly enrollmentTime: string;\n\n  protected constructor(readonly factorId: FactorId, response: MfaEnrollment) {\n    this.uid = response.mfaEnrollmentId;\n    this.enrollmentTime = new Date(response.enrolledAt).toUTCString();\n    this.displayName = response.displayName;\n  }\n\n  static _fromServerResponse(\n    auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): MultiFactorInfoImpl {\n    if ('phoneInfo' in enrollment) {\n      return PhoneMultiFactorInfoImpl._fromServerResponse(auth, enrollment);\n    } else if ('totpInfo' in enrollment) {\n      return TotpMultiFactorInfoImpl._fromServerResponse(auth, enrollment);\n    }\n    return _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n  }\n}\n\nexport class PhoneMultiFactorInfoImpl\n  extends MultiFactorInfoImpl\n  implements PhoneMultiFactorInfo\n{\n  readonly phoneNumber: string;\n\n  private constructor(response: PhoneMfaEnrollment) {\n    super(FactorId.PHONE, response);\n    this.phoneNumber = response.phoneInfo;\n  }\n\n  static _fromServerResponse(\n    _auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): PhoneMultiFactorInfoImpl {\n    return new PhoneMultiFactorInfoImpl(enrollment as PhoneMfaEnrollment);\n  }\n}\nexport class TotpMultiFactorInfoImpl\n  extends MultiFactorInfoImpl\n  implements TotpMultiFactorInfo\n{\n  private constructor(response: TotpMfaEnrollment) {\n    super(FactorId.TOTP, response);\n  }\n\n  static _fromServerResponse(\n    _auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): TotpMultiFactorInfoImpl {\n    return new TotpMultiFactorInfoImpl(enrollment as TotpMfaEnrollment);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeSettings, Auth } from '../../model/public_types';\n\nimport { GetOobCodeRequest } from '../../api/authentication/email_and_password';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\n\nexport function _setActionCodeSettingsOnRequest(\n  auth: Auth,\n  request: GetOobCodeRequest,\n  actionCodeSettings: ActionCodeSettings\n): void {\n  _assert(\n    actionCodeSettings.url?.length > 0,\n    auth,\n    AuthErrorCode.INVALID_CONTINUE_URI\n  );\n  _assert(\n    typeof actionCodeSettings.dynamicLinkDomain === 'undefined' ||\n      actionCodeSettings.dynamicLinkDomain.length > 0,\n    auth,\n    AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN\n  );\n  _assert(\n    typeof actionCodeSettings.linkDomain === 'undefined' ||\n      actionCodeSettings.linkDomain.length > 0,\n    auth,\n    AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN\n  );\n\n  request.continueUrl = actionCodeSettings.url;\n  request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;\n  request.linkDomain = actionCodeSettings.linkDomain;\n  request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;\n\n  if (actionCodeSettings.iOS) {\n    _assert(\n      actionCodeSettings.iOS.bundleId.length > 0,\n      auth,\n      AuthErrorCode.MISSING_IOS_BUNDLE_ID\n    );\n    request.iOSBundleId = actionCodeSettings.iOS.bundleId;\n  }\n\n  if (actionCodeSettings.android) {\n    _assert(\n      actionCodeSettings.android.packageName.length > 0,\n      auth,\n      AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME\n    );\n    request.androidInstallApp = actionCodeSettings.android.installApp;\n    request.androidMinimumVersionCode =\n      actionCodeSettings.android.minimumVersion;\n    request.androidPackageName = actionCodeSettings.android.packageName;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeInfo,\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  UserCredential\n} from '../../model/public_types';\n\nimport * as account from '../../api/account_management/email_and_password';\nimport * as authentication from '../../api/authentication/email_and_password';\nimport { signUp, SignUpRequest } from '../../api/authentication/sign_up';\nimport { MultiFactorInfoImpl } from '../../mfa/mfa_info';\nimport { EmailAuthProvider } from '../providers/email';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport {\n  _assert,\n  _serverAppCurrentUserOperationNotSupportedError\n} from '../util/assert';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { signInWithCredential } from './credential';\nimport { _castAuth } from '../auth/auth_impl';\nimport { AuthErrorCode } from '../errors';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../../model/enums';\nimport { handleRecaptchaFlow } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { IdTokenResponse } from '../../model/id_token';\nimport {\n  RecaptchaActionName,\n  RecaptchaClientType,\n  RecaptchaAuthProvider\n} from '../../api';\nimport { _isFirebaseServerApp } from '@firebase/app';\n\n/**\n * Updates the password policy cached in the {@link Auth} instance if a policy is already\n * cached for the project or tenant.\n *\n * @remarks\n * We only fetch the password policy if the password did not meet policy requirements and\n * there is an existing policy cached. A developer must call validatePassword at least\n * once for the cache to be automatically updated.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @private\n */\nasync function recachePasswordPolicy(auth: Auth): Promise<void> {\n  const authInternal = _castAuth(auth);\n  if (authInternal._getPasswordPolicyInternal()) {\n    await authInternal._updatePasswordPolicy();\n  }\n}\n\n/**\n * Sends a password reset email to the given email address. This method does not throw an error when\n * there's no user account with the given email address and\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled.\n *\n * @remarks\n * To complete the password reset, call {@link confirmPasswordReset} with the code supplied in\n * the email sent to the user, along with the new password specified by the user.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendPasswordResetEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain code from user.\n * await confirmPasswordReset('user@example.com', code);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendPasswordResetEmail(\n  auth: Auth,\n  email: string,\n  actionCodeSettings?: ActionCodeSettings\n): Promise<void> {\n  const authInternal = _castAuth(auth);\n  const request: authentication.PasswordResetRequest = {\n    requestType: ActionCodeOperation.PASSWORD_RESET,\n    email,\n    clientType: RecaptchaClientType.WEB\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(authInternal, request, actionCodeSettings);\n  }\n  await handleRecaptchaFlow(\n    authInternal,\n    request,\n    RecaptchaActionName.GET_OOB_CODE,\n    authentication.sendPasswordResetEmail,\n    RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n  );\n}\n\n/**\n * Completes the password reset process, given a confirmation code and new password.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A confirmation code sent to the user.\n * @param newPassword - The new password.\n *\n * @public\n */\nexport async function confirmPasswordReset(\n  auth: Auth,\n  oobCode: string,\n  newPassword: string\n): Promise<void> {\n  await account\n    .resetPassword(getModularInstance(auth), {\n      oobCode,\n      newPassword\n    })\n    .catch(async error => {\n      if (\n        error.code ===\n        `auth/${AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS}`\n      ) {\n        void recachePasswordPolicy(auth);\n      }\n\n      throw error;\n    });\n  // Do not return the email.\n}\n\n/**\n * Applies a verification code sent to the user by email or other out-of-band mechanism.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A verification code sent to the user.\n *\n * @public\n */\nexport async function applyActionCode(\n  auth: Auth,\n  oobCode: string\n): Promise<void> {\n  await account.applyActionCode(getModularInstance(auth), { oobCode });\n}\n\n/**\n * Checks a verification code sent to the user by email or other out-of-band mechanism.\n *\n * @returns metadata about the code.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A verification code sent to the user.\n *\n * @public\n */\nexport async function checkActionCode(\n  auth: Auth,\n  oobCode: string\n): Promise<ActionCodeInfo> {\n  const authModular = getModularInstance(auth);\n  const response = await account.resetPassword(authModular, { oobCode });\n\n  // Email could be empty only if the request type is EMAIL_SIGNIN or\n  // VERIFY_AND_CHANGE_EMAIL.\n  // New email should not be empty if the request type is\n  // VERIFY_AND_CHANGE_EMAIL.\n  // Multi-factor info could not be empty if the request type is\n  // REVERT_SECOND_FACTOR_ADDITION.\n  const operation = response.requestType;\n  _assert(operation, authModular, AuthErrorCode.INTERNAL_ERROR);\n  switch (operation) {\n    case ActionCodeOperation.EMAIL_SIGNIN:\n      break;\n    case ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL:\n      _assert(response.newEmail, authModular, AuthErrorCode.INTERNAL_ERROR);\n      break;\n    case ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION:\n      _assert(response.mfaInfo, authModular, AuthErrorCode.INTERNAL_ERROR);\n    // fall through\n    default:\n      _assert(response.email, authModular, AuthErrorCode.INTERNAL_ERROR);\n  }\n\n  // The multi-factor info for revert second factor addition\n  let multiFactorInfo: MultiFactorInfoImpl | null = null;\n  if (response.mfaInfo) {\n    multiFactorInfo = MultiFactorInfoImpl._fromServerResponse(\n      _castAuth(authModular),\n      response.mfaInfo\n    );\n  }\n\n  return {\n    data: {\n      email:\n        (response.requestType === ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL\n          ? response.newEmail\n          : response.email) || null,\n      previousEmail:\n        (response.requestType === ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL\n          ? response.email\n          : response.newEmail) || null,\n      multiFactorInfo\n    },\n    operation\n  };\n}\n\n/**\n * Checks a password reset code sent to the user by email or other out-of-band mechanism.\n *\n * @returns the user's email address if valid.\n *\n * @param auth - The {@link Auth} instance.\n * @param code - A verification code sent to the user.\n *\n * @public\n */\nexport async function verifyPasswordResetCode(\n  auth: Auth,\n  code: string\n): Promise<string> {\n  const { data } = await checkActionCode(getModularInstance(auth), code);\n  // Email should always be present since a code was sent to it\n  return data.email!;\n}\n\n/**\n * Creates a new user account associated with the specified email address and password.\n *\n * @remarks\n * On successful creation of the user account, this user will also be signed in to your application.\n *\n * User account creation can fail if the account already exists or the password is invalid.\n *\n * This method is not supported on {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * Note: The email address acts as a unique identifier for the user and enables an email-based\n * password reset. This function will create a new user account and set the initial user password.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param password - The user's chosen password.\n *\n * @public\n */\nexport async function createUserWithEmailAndPassword(\n  auth: Auth,\n  email: string,\n  password: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authInternal = _castAuth(auth);\n  const request: SignUpRequest = {\n    returnSecureToken: true,\n    email,\n    password,\n    clientType: RecaptchaClientType.WEB\n  };\n  const signUpResponse: Promise<IdTokenResponse> = handleRecaptchaFlow(\n    authInternal,\n    request,\n    RecaptchaActionName.SIGN_UP_PASSWORD,\n    signUp,\n    RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n  );\n  const response = await signUpResponse.catch(error => {\n    if (\n      error.code === `auth/${AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS}`\n    ) {\n      void recachePasswordPolicy(auth);\n    }\n\n    throw error;\n  });\n\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response\n  );\n  await authInternal._updateCurrentUser(userCredential.user);\n\n  return userCredential;\n}\n\n/**\n * Asynchronously signs in using an email and password.\n *\n * @remarks\n * Fails with an error if the email address and password do not match. When\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled, this method fails with \"auth/invalid-credential\" in case of an invalid\n * email/password.\n *\n * This method is not supported on {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * Note: The user's password is NOT the password used to access the user's email account. The\n * email address serves as a unique identifier for the user, and the password is used to access\n * the user's account in your Firebase project. See also: {@link createUserWithEmailAndPassword}.\n *\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The users email address.\n * @param password - The users password.\n *\n * @public\n */\nexport function signInWithEmailAndPassword(\n  auth: Auth,\n  email: string,\n  password: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  return signInWithCredential(\n    getModularInstance(auth),\n    EmailAuthProvider.credential(email, password)\n  ).catch(async error => {\n    if (\n      error.code === `auth/${AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS}`\n    ) {\n      void recachePasswordPolicy(auth);\n    }\n\n    throw error;\n  });\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  UserCredential\n} from '../../model/public_types';\n\nimport * as api from '../../api/authentication/email_and_password';\nimport { ActionCodeURL } from '../action_code_url';\nimport { EmailAuthProvider } from '../providers/email';\nimport { _getCurrentUrl } from '../util/location';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { signInWithCredential } from './credential';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { getModularInstance } from '@firebase/util';\nimport { _castAuth } from '../auth/auth_impl';\nimport { handleRecaptchaFlow } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport {\n  RecaptchaActionName,\n  RecaptchaClientType,\n  RecaptchaAuthProvider\n} from '../../api';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\n/**\n * Sends a sign-in email link to the user with the specified email.\n *\n * @remarks\n * The sign-in operation has to always be completed in the app unlike other out of band email\n * actions (password reset and email verifications). This is because, at the end of the flow,\n * the user is expected to be signed in and their Auth state persisted within the app.\n *\n * To complete sign in with the email link, call {@link signInWithEmailLink} with the email\n * address and the email link supplied in the email sent to the user.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain emailLink from the user.\n * if(isSignInWithEmailLink(auth, emailLink)) {\n *   await signInWithEmailLink(auth, 'user@example.com', emailLink);\n * }\n * ```\n *\n * @param authInternal - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendSignInLinkToEmail(\n  auth: Auth,\n  email: string,\n  actionCodeSettings: ActionCodeSettings\n): Promise<void> {\n  const authInternal = _castAuth(auth);\n  const request: api.EmailSignInRequest = {\n    requestType: ActionCodeOperation.EMAIL_SIGNIN,\n    email,\n    clientType: RecaptchaClientType.WEB\n  };\n  function setActionCodeSettings(\n    request: api.EmailSignInRequest,\n    actionCodeSettings: ActionCodeSettings\n  ): void {\n    _assert(\n      actionCodeSettings.handleCodeInApp,\n      authInternal,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    if (actionCodeSettings) {\n      _setActionCodeSettingsOnRequest(\n        authInternal,\n        request,\n        actionCodeSettings\n      );\n    }\n  }\n  setActionCodeSettings(request, actionCodeSettings);\n  await handleRecaptchaFlow(\n    authInternal,\n    request,\n    RecaptchaActionName.GET_OOB_CODE,\n    api.sendSignInLinkToEmail,\n    RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n  );\n}\n\n/**\n * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.\n *\n * @param auth - The {@link Auth} instance.\n * @param emailLink - The link sent to the user's email address.\n *\n * @public\n */\nexport function isSignInWithEmailLink(auth: Auth, emailLink: string): boolean {\n  const actionCodeUrl = ActionCodeURL.parseLink(emailLink);\n  return actionCodeUrl?.operation === ActionCodeOperation.EMAIL_SIGNIN;\n}\n\n/**\n * Asynchronously signs in using an email and sign-in email link.\n *\n * @remarks\n * If no link is passed, the link is inferred from the current URL.\n *\n * Fails with an error if the email address is invalid or OTP in email link expires.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * Note: Confirm the link is a sign-in email link before calling this method firebase.auth.Auth.isSignInWithEmailLink.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain emailLink from the user.\n * if(isSignInWithEmailLink(auth, emailLink)) {\n *   await signInWithEmailLink(auth, 'user@example.com', emailLink);\n * }\n * ```\n *\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param emailLink - The link sent to the user's email address.\n *\n * @public\n */\nexport async function signInWithEmailLink(\n  auth: Auth,\n  email: string,\n  emailLink?: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authModular = getModularInstance(auth);\n  const credential = EmailAuthProvider.credentialWithLink(\n    email,\n    emailLink || _getCurrentUrl()\n  );\n  // Check if the tenant ID in the email link matches the tenant ID on Auth\n  // instance.\n  _assert(\n    credential._tenantId === (authModular.tenantId || null),\n    authModular,\n    AuthErrorCode.TENANT_ID_MISMATCH\n  );\n  return signInWithCredential(authModular, credential);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\nexport interface CreateAuthUriRequest {\n  identifier: string;\n  continueUri: string;\n  tenantId?: string;\n}\n\nexport interface CreateAuthUriResponse {\n  signinMethods: string[];\n}\n\nexport async function createAuthUri(\n  auth: Auth,\n  request: CreateAuthUriRequest\n): Promise<CreateAuthUriResponse> {\n  return _performApiRequest<CreateAuthUriRequest, CreateAuthUriResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.CREATE_AUTH_URI,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  User\n} from '../../model/public_types';\n\nimport {\n  createAuthUri,\n  CreateAuthUriRequest\n} from '../../api/authentication/create_auth_uri';\nimport * as api from '../../api/authentication/email_and_password';\nimport { UserInternal } from '../../model/user';\nimport { _getCurrentUrl, _isHttpOrHttps } from '../util/location';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { getModularInstance } from '@firebase/util';\n\n/**\n * Gets the list of possible sign in methods for the given email address. This method returns an\n * empty list when\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled, irrespective of the number of authentication methods available for the given email.\n *\n * @remarks\n * This is useful to differentiate methods of sign-in for the same provider, eg.\n * {@link EmailAuthProvider} which has 2 methods of sign-in,\n * {@link SignInMethod}.EMAIL_PASSWORD and\n * {@link SignInMethod}.EMAIL_LINK.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n *\n * Deprecated. Migrating off of this method is recommended as a security best-practice.\n * Learn more in the Identity Platform documentation for\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}.\n * @public\n */\nexport async function fetchSignInMethodsForEmail(\n  auth: Auth,\n  email: string\n): Promise<string[]> {\n  // createAuthUri returns an error if continue URI is not http or https.\n  // For environments like Cordova, Chrome extensions, native frameworks, file\n  // systems, etc, use http://localhost as continue URL.\n  const continueUri = _isHttpOrHttps() ? _getCurrentUrl() : 'http://localhost';\n  const request: CreateAuthUriRequest = {\n    identifier: email,\n    continueUri\n  };\n\n  const { signinMethods } = await createAuthUri(\n    getModularInstance(auth),\n    request\n  );\n\n  return signinMethods || [];\n}\n\n/**\n * Sends a verification email to a user.\n *\n * @remarks\n * The verification process is completed by calling {@link applyActionCode}.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendEmailVerification(user, actionCodeSettings);\n * // Obtain code from the user.\n * await applyActionCode(auth, code);\n * ```\n *\n * @param user - The user.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendEmailVerification(\n  user: User,\n  actionCodeSettings?: ActionCodeSettings | null\n): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await user.getIdToken();\n  const request: api.VerifyEmailRequest = {\n    requestType: ActionCodeOperation.VERIFY_EMAIL,\n    idToken\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(\n      userInternal.auth,\n      request,\n      actionCodeSettings\n    );\n  }\n\n  const { email } = await api.sendEmailVerification(userInternal.auth, request);\n\n  if (email !== user.email) {\n    await user.reload();\n  }\n}\n\n/**\n * Sends a verification email to a new email address.\n *\n * @remarks\n * The user's email will be updated to the new one after being verified.\n *\n * If you have a custom email action handler, you can complete the verification process by calling\n * {@link applyActionCode}.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await verifyBeforeUpdateEmail(user, 'newemail@example.com', actionCodeSettings);\n * // Obtain code from the user.\n * await applyActionCode(auth, code);\n * ```\n *\n * @param user - The user.\n * @param newEmail - The new email address to be verified before update.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function verifyBeforeUpdateEmail(\n  user: User,\n  newEmail: string,\n  actionCodeSettings?: ActionCodeSettings | null\n): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await user.getIdToken();\n  const request: api.VerifyAndChangeEmailRequest = {\n    requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL,\n    idToken,\n    newEmail\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(\n      userInternal.auth,\n      request,\n      actionCodeSettings\n    );\n  }\n\n  const { email } = await api.verifyAndChangeEmail(userInternal.auth, request);\n\n  if (email !== user.email) {\n    // If the local copy of the email on user is outdated, reload the\n    // user.\n    await user.reload();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface UpdateProfileRequest {\n  idToken: string;\n  displayName?: string | null;\n  photoUrl?: string | null;\n  returnSecureToken: boolean;\n}\n\nexport interface UpdateProfileResponse extends IdTokenResponse {\n  displayName?: string | null;\n  photoUrl?: string | null;\n}\n\nexport async function updateProfile(\n  auth: Auth,\n  request: UpdateProfileRequest\n): Promise<UpdateProfileResponse> {\n  return _performApiRequest<UpdateProfileRequest, UpdateProfileResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SET_ACCOUNT_INFO,\n    request\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User } from '../../model/public_types';\n\nimport {\n  updateEmailPassword as apiUpdateEmailPassword,\n  UpdateEmailPasswordRequest\n} from '../../api/account_management/email_and_password';\nimport { updateProfile as apiUpdateProfile } from '../../api/account_management/profile';\nimport { UserInternal } from '../../model/user';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { getModularInstance } from '@firebase/util';\nimport { ProviderId } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\n/**\n * Updates a user's profile data.\n *\n * @param user - The user.\n * @param profile - The profile's `displayName` and `photoURL` to update.\n *\n * @public\n */\nexport async function updateProfile(\n  user: User,\n  {\n    displayName,\n    photoURL: photoUrl\n  }: { displayName?: string | null; photoURL?: string | null }\n): Promise<void> {\n  if (displayName === undefined && photoUrl === undefined) {\n    return;\n  }\n\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await userInternal.getIdToken();\n  const profileRequest = {\n    idToken,\n    displayName,\n    photoUrl,\n    returnSecureToken: true\n  };\n  const response = await _logoutIfInvalidated(\n    userInternal,\n    apiUpdateProfile(userInternal.auth, profileRequest)\n  );\n\n  userInternal.displayName = response.displayName || null;\n  userInternal.photoURL = response.photoUrl || null;\n\n  // Update the password provider as well\n  const passwordProvider = userInternal.providerData.find(\n    ({ providerId }) => providerId === ProviderId.PASSWORD\n  );\n  if (passwordProvider) {\n    passwordProvider.displayName = userInternal.displayName;\n    passwordProvider.photoURL = userInternal.photoURL;\n  }\n\n  await userInternal._updateTokensIfNecessary(response);\n}\n\n/**\n * Updates the user's email address.\n *\n * @remarks\n * An email will be sent to the original email address (if it was set) that allows to revoke the\n * email address change, in order to protect them from account hijacking.\n *\n * This method is not supported on any {@link User} signed in by {@link Auth} instances\n * created with a {@link @firebase/app#FirebaseServerApp}.\n *\n * Important: this is a security sensitive operation that requires the user to have recently signed\n * in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n * @param newEmail - The new email address.\n *\n * Throws \"auth/operation-not-allowed\" error when\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled.\n * Deprecated - Use {@link verifyBeforeUpdateEmail} instead.\n *\n * @public\n */\nexport function updateEmail(user: User, newEmail: string): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  if (_isFirebaseServerApp(userInternal.auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(userInternal.auth)\n    );\n  }\n  return updateEmailOrPassword(userInternal, newEmail, null);\n}\n\n/**\n * Updates the user's password.\n *\n * @remarks\n * Important: this is a security sensitive operation that requires the user to have recently signed\n * in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n * @param newPassword - The new password.\n *\n * @public\n */\nexport function updatePassword(user: User, newPassword: string): Promise<void> {\n  return updateEmailOrPassword(\n    getModularInstance(user) as UserInternal,\n    null,\n    newPassword\n  );\n}\n\nasync function updateEmailOrPassword(\n  user: UserInternal,\n  email: string | null,\n  password: string | null\n): Promise<void> {\n  const { auth } = user;\n  const idToken = await user.getIdToken();\n  const request: UpdateEmailPasswordRequest = {\n    idToken,\n    returnSecureToken: true\n  };\n\n  if (email) {\n    request.email = email;\n  }\n\n  if (password) {\n    request.password = password;\n  }\n\n  const response = await _logoutIfInvalidated(\n    user,\n    apiUpdateEmailPassword(auth, request)\n  );\n  await user._updateTokensIfNecessary(response, /* reload */ true);\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AdditionalUserInfo, UserCredential } from '../../model/public_types';\nimport { IdTokenResponse, IdTokenResponseKind } from '../../model/id_token';\nimport { _parseToken } from './id_token_result';\nimport { UserCredentialInternal } from '../../model/user';\nimport { ProviderId } from '../../model/enums';\n\n/**\n * Parse the `AdditionalUserInfo` from the ID token response.\n *\n */\nexport function _fromIdTokenResponse(\n  idTokenResponse?: IdTokenResponse\n): AdditionalUserInfo | null {\n  if (!idTokenResponse) {\n    return null;\n  }\n  const { providerId } = idTokenResponse;\n  const profile = idTokenResponse.rawUserInfo\n    ? JSON.parse(idTokenResponse.rawUserInfo)\n    : {};\n  const isNewUser =\n    idTokenResponse.isNewUser ||\n    idTokenResponse.kind === IdTokenResponseKind.SignupNewUser;\n  if (!providerId && idTokenResponse?.idToken) {\n    const signInProvider = _parseToken(idTokenResponse.idToken)?.firebase?.[\n      'sign_in_provider'\n    ];\n    if (signInProvider) {\n      const filteredProviderId =\n        signInProvider !== ProviderId.ANONYMOUS &&\n        signInProvider !== ProviderId.CUSTOM\n          ? (signInProvider as ProviderId)\n          : null;\n      // Uses generic class in accordance with the legacy SDK.\n      return new GenericAdditionalUserInfo(isNewUser, filteredProviderId);\n    }\n  }\n  if (!providerId) {\n    return null;\n  }\n  switch (providerId) {\n    case ProviderId.FACEBOOK:\n      return new FacebookAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.GITHUB:\n      return new GithubAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.GOOGLE:\n      return new GoogleAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.TWITTER:\n      return new TwitterAdditionalUserInfo(\n        isNewUser,\n        profile,\n        idTokenResponse.screenName || null\n      );\n    case ProviderId.CUSTOM:\n    case ProviderId.ANONYMOUS:\n      return new GenericAdditionalUserInfo(isNewUser, null);\n    default:\n      return new GenericAdditionalUserInfo(isNewUser, providerId, profile);\n  }\n}\n\nclass GenericAdditionalUserInfo implements AdditionalUserInfo {\n  constructor(\n    readonly isNewUser: boolean,\n    readonly providerId: ProviderId | string | null,\n    readonly profile: Record<string, unknown> = {}\n  ) {}\n}\n\nclass FederatedAdditionalUserInfoWithUsername extends GenericAdditionalUserInfo {\n  constructor(\n    isNewUser: boolean,\n    providerId: ProviderId,\n    profile: Record<string, unknown>,\n    readonly username: string | null\n  ) {\n    super(isNewUser, providerId, profile);\n  }\n}\n\nclass FacebookAdditionalUserInfo extends GenericAdditionalUserInfo {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(isNewUser, ProviderId.FACEBOOK, profile);\n  }\n}\n\nclass GithubAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(\n      isNewUser,\n      ProviderId.GITHUB,\n      profile,\n      typeof profile?.login === 'string' ? profile?.login : null\n    );\n  }\n}\n\nclass GoogleAdditionalUserInfo extends GenericAdditionalUserInfo {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(isNewUser, ProviderId.GOOGLE, profile);\n  }\n}\n\nclass TwitterAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {\n  constructor(\n    isNewUser: boolean,\n    profile: Record<string, unknown>,\n    screenName: string | null\n  ) {\n    super(isNewUser, ProviderId.TWITTER, profile, screenName);\n  }\n}\n\n/**\n * Extracts provider specific {@link AdditionalUserInfo} for the given credential.\n *\n * @param userCredential - The user credential.\n *\n * @public\n */\nexport function getAdditionalUserInfo(\n  userCredential: UserCredential\n): AdditionalUserInfo | null {\n  const { user, _tokenResponse } = userCredential as UserCredentialInternal;\n  if (user.isAnonymous && !_tokenResponse) {\n    // Handle the special case where signInAnonymously() gets called twice.\n    // No network call is made so there's nothing to actually fill this in\n    return {\n      providerId: null,\n      isNewUser: false,\n      profile: null\n    };\n  }\n\n  return _fromIdTokenResponse(_tokenResponse);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getModularInstance } from '@firebase/util';\nimport {\n  Auth,\n  NextOrObserver,\n  Persistence,\n  User,\n  CompleteFn,\n  ErrorFn,\n  Unsubscribe,\n  PasswordValidationStatus\n} from '../model/public_types';\nimport { _initializeRecaptchaConfig } from '../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { _castAuth } from '../core/auth/auth_impl';\n\nexport {\n  debugErrorMap,\n  prodErrorMap,\n  AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as AuthErrorCodes\n} from './errors';\n\n// Non-optional auth methods.\n/**\n * Changes the type of persistence on the {@link Auth} instance for the currently saved\n * `Auth` session and applies this type of persistence for future sign-in requests, including\n * sign-in with redirect requests.\n *\n * @remarks\n * This makes it easy for a user signing in to specify whether their session should be\n * remembered or not. It also makes it easier to never persist the `Auth` state for applications\n * that are shared by other users or have sensitive data.\n *\n * This method does not work in a Node.js environment or with {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @example\n * ```javascript\n * setPersistence(auth, browserSessionPersistence);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param persistence - The {@link Persistence} to use.\n * @returns A `Promise` that resolves once the persistence change has completed\n *\n * @public\n */\nexport function setPersistence(\n  auth: Auth,\n  persistence: Persistence\n): Promise<void> {\n  return getModularInstance(auth).setPersistence(persistence);\n}\n\n/**\n * Loads the reCAPTCHA configuration into the `Auth` instance.\n *\n * @remarks\n * This will load the reCAPTCHA config, which indicates whether the reCAPTCHA\n * verification flow should be triggered for each auth provider, into the\n * current Auth session.\n *\n * If initializeRecaptchaConfig() is not invoked, the auth flow will always start\n * without reCAPTCHA verification. If the provider is configured to require reCAPTCHA\n * verification, the SDK will transparently load the reCAPTCHA config and restart the\n * auth flows.\n *\n * Thus, by calling this optional method, you will reduce the latency of future auth flows.\n * Loading the reCAPTCHA config early will also enhance the signal collected by reCAPTCHA.\n *\n * This method does not work in a Node.js environment.\n *\n * @example\n * ```javascript\n * initializeRecaptchaConfig(auth);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function initializeRecaptchaConfig(auth: Auth): Promise<void> {\n  return _initializeRecaptchaConfig(auth);\n}\n\n/**\n * Validates the password against the password policy configured for the project or tenant.\n *\n * @remarks\n * If no tenant ID is set on the `Auth` instance, then this method will use the password\n * policy configured for the project. Otherwise, this method will use the policy configured\n * for the tenant. If a password policy has not been configured, then the default policy\n * configured for all projects will be used.\n *\n * If an auth flow fails because a submitted password does not meet the password policy\n * requirements and this method has previously been called, then this method will use the\n * most recent policy available when called again.\n *\n * @example\n * ```javascript\n * validatePassword(auth, 'some-password');\n * ```\n *\n * @param auth The {@link Auth} instance.\n * @param password The password to validate.\n *\n * @public\n */\nexport async function validatePassword(\n  auth: Auth,\n  password: string\n): Promise<PasswordValidationStatus> {\n  const authInternal = _castAuth(auth);\n  return authInternal.validatePassword(password);\n}\n\n/**\n * Adds an observer for changes to the signed-in user's ID token.\n *\n * @remarks\n * This includes sign-in, sign-out, and token refresh events.\n * This will not be triggered automatically upon ID token expiration. Use {@link User.getIdToken} to refresh the ID token.\n *\n * @param auth - The {@link Auth} instance.\n * @param nextOrObserver - callback triggered on change.\n * @param error - Deprecated. This callback is never triggered. Errors\n * on signing in/out can be caught in promises returned from\n * sign-in/sign-out functions.\n * @param completed - Deprecated. This callback is never triggered.\n *\n * @public\n */\nexport function onIdTokenChanged(\n  auth: Auth,\n  nextOrObserver: NextOrObserver<User>,\n  error?: ErrorFn,\n  completed?: CompleteFn\n): Unsubscribe {\n  return getModularInstance(auth).onIdTokenChanged(\n    nextOrObserver,\n    error,\n    completed\n  );\n}\n/**\n * Adds a blocking callback that runs before an auth state change\n * sets a new user.\n *\n * @param auth - The {@link Auth} instance.\n * @param callback - callback triggered before new user value is set.\n *   If this throws, it blocks the user from being set.\n * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`\n *   callback throws, allowing you to undo any side effects.\n */\nexport function beforeAuthStateChanged(\n  auth: Auth,\n  callback: (user: User | null) => void | Promise<void>,\n  onAbort?: () => void\n): Unsubscribe {\n  return getModularInstance(auth).beforeAuthStateChanged(callback, onAbort);\n}\n/**\n * Adds an observer for changes to the user's sign-in state.\n *\n * @remarks\n * To keep the old behavior, see {@link onIdTokenChanged}.\n *\n * @param auth - The {@link Auth} instance.\n * @param nextOrObserver - callback triggered on change.\n * @param error - Deprecated. This callback is never triggered. Errors\n * on signing in/out can be caught in promises returned from\n * sign-in/sign-out functions.\n * @param completed - Deprecated. This callback is never triggered.\n *\n * @public\n */\nexport function onAuthStateChanged(\n  auth: Auth,\n  nextOrObserver: NextOrObserver<User>,\n  error?: ErrorFn,\n  completed?: CompleteFn\n): Unsubscribe {\n  return getModularInstance(auth).onAuthStateChanged(\n    nextOrObserver,\n    error,\n    completed\n  );\n}\n/**\n * Sets the current language to the default device/browser preference.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function useDeviceLanguage(auth: Auth): void {\n  getModularInstance(auth).useDeviceLanguage();\n}\n/**\n * Asynchronously sets the provided user as {@link Auth.currentUser} on the\n * {@link Auth} instance.\n *\n * @remarks\n * A new instance copy of the user provided will be made and set as currentUser.\n *\n * This will trigger {@link onAuthStateChanged} and {@link onIdTokenChanged} listeners\n * like other sign in methods.\n *\n * The operation fails with an error if the user to be updated belongs to a different Firebase\n * project.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n * @param user - The new {@link User}.\n *\n * @public\n */\nexport function updateCurrentUser(\n  auth: Auth,\n  user: User | null\n): Promise<void> {\n  return getModularInstance(auth).updateCurrentUser(user);\n}\n/**\n * Signs out the current user.\n *\n * @remarks\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function signOut(auth: Auth): Promise<void> {\n  return getModularInstance(auth).signOut();\n}\n\n/**\n * Revokes the given access token. Currently only supports Apple OAuth access tokens.\n *\n * @param auth - The {@link Auth} instance.\n * @param token - The Apple OAuth access token.\n *\n * @public\n */\nexport function revokeAccessToken(auth: Auth, token: string): Promise<void> {\n  const authInternal = _castAuth(auth);\n  return authInternal.revokeAccessToken(token);\n}\n\nexport { initializeAuth } from './auth/initialize';\nexport { connectAuthEmulator } from './auth/emulator';\n\n// credentials\nexport { AuthCredential } from './credentials';\nexport { EmailAuthCredential } from './credentials/email';\nexport { OAuthCredential } from './credentials/oauth';\nexport { PhoneAuthCredential } from './credentials/phone';\n\n// persistence\nexport { inMemoryPersistence } from './persistence/in_memory';\n\n// providers\nexport { EmailAuthProvider } from './providers/email';\nexport { FacebookAuthProvider } from './providers/facebook';\nexport { CustomParameters } from './providers/federated';\nexport { GoogleAuthProvider } from './providers/google';\nexport { GithubAuthProvider } from './providers/github';\nexport { OAuthProvider, OAuthCredentialOptions } from './providers/oauth';\nexport { SAMLAuthProvider } from './providers/saml';\nexport { TwitterAuthProvider } from './providers/twitter';\n\n// strategies\nexport { signInAnonymously } from './strategies/anonymous';\nexport {\n  signInWithCredential,\n  linkWithCredential,\n  reauthenticateWithCredential\n} from './strategies/credential';\nexport { signInWithCustomToken } from './strategies/custom_token';\nexport {\n  sendPasswordResetEmail,\n  confirmPasswordReset,\n  applyActionCode,\n  checkActionCode,\n  verifyPasswordResetCode,\n  createUserWithEmailAndPassword,\n  signInWithEmailAndPassword\n} from './strategies/email_and_password';\nexport {\n  sendSignInLinkToEmail,\n  isSignInWithEmailLink,\n  signInWithEmailLink\n} from './strategies/email_link';\nexport {\n  fetchSignInMethodsForEmail,\n  sendEmailVerification,\n  verifyBeforeUpdateEmail\n} from './strategies/email';\n\n// core\nexport { ActionCodeURL, parseActionCodeURL } from './action_code_url';\n\n// user\nexport {\n  updateProfile,\n  updateEmail,\n  updatePassword\n} from './user/account_info';\nexport { getIdToken, getIdTokenResult } from './user/id_token_result';\nexport { unlink } from './user/link_unlink';\nexport { getAdditionalUserInfo } from './user/additional_user_info';\n\n// Non-optional user methods.\nexport { reload } from './user/reload';\n/**\n * Deletes and signs out the user.\n *\n * @remarks\n * Important: this is a security-sensitive operation that requires the user to have recently\n * signed in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n *\n * @public\n */\nexport async function deleteUser(user: User): Promise<void> {\n  return getModularInstance(user).delete();\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserInternal } from '../model/user';\nimport { MultiFactorSession } from '../model/public_types';\n\nexport const enum MultiFactorSessionType {\n  ENROLL = 'enroll',\n  SIGN_IN = 'signin'\n}\n\ninterface SerializedMultiFactorSession {\n  multiFactorSession: {\n    idToken?: string;\n    pendingCredential?: string;\n  };\n}\n\nexport class MultiFactorSessionImpl implements MultiFactorSession {\n  private constructor(\n    readonly type: MultiFactorSessionType,\n    readonly credential: string,\n    readonly user?: UserInternal\n  ) {}\n\n  static _fromIdtoken(\n    idToken: string,\n    user?: UserInternal\n  ): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(\n      MultiFactorSessionType.ENROLL,\n      idToken,\n      user\n    );\n  }\n\n  static _fromMfaPendingCredential(\n    mfaPendingCredential: string\n  ): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(\n      MultiFactorSessionType.SIGN_IN,\n      mfaPendingCredential\n    );\n  }\n\n  toJSON(): SerializedMultiFactorSession {\n    const key =\n      this.type === MultiFactorSessionType.ENROLL\n        ? 'idToken'\n        : 'pendingCredential';\n    return {\n      multiFactorSession: {\n        [key]: this.credential\n      }\n    };\n  }\n\n  static fromJSON(\n    obj: Partial<SerializedMultiFactorSession>\n  ): MultiFactorSessionImpl | null {\n    if (obj?.multiFactorSession) {\n      if (obj.multiFactorSession?.pendingCredential) {\n        return MultiFactorSessionImpl._fromMfaPendingCredential(\n          obj.multiFactorSession.pendingCredential\n        );\n      } else if (obj.multiFactorSession?.idToken) {\n        return MultiFactorSessionImpl._fromIdtoken(\n          obj.multiFactorSession.idToken\n        );\n      }\n    }\n    return null;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Auth,\n  MultiFactorResolver,\n  UserCredential,\n  MultiFactorError\n} from '../model/public_types';\n\nimport { _castAuth } from '../core/auth/auth_impl';\nimport { AuthErrorCode } from '../core/errors';\nimport { UserCredentialImpl } from '../core/user/user_credential_impl';\nimport { _assert, _fail } from '../core/util/assert';\nimport { UserCredentialInternal } from '../model/user';\nimport { MultiFactorAssertionImpl } from './mfa_assertion';\nimport { MultiFactorError as MultiFactorErrorInternal } from './mfa_error';\nimport { MultiFactorInfoImpl } from './mfa_info';\nimport { MultiFactorSessionImpl } from './mfa_session';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../model/enums';\n\nexport class MultiFactorResolverImpl implements MultiFactorResolver {\n  private constructor(\n    readonly session: MultiFactorSessionImpl,\n    readonly hints: MultiFactorInfoImpl[],\n    private readonly signInResolver: (\n      assertion: MultiFactorAssertionImpl\n    ) => Promise<UserCredentialInternal>\n  ) {}\n\n  /** @internal */\n  static _fromError(\n    authExtern: Auth,\n    error: MultiFactorErrorInternal\n  ): MultiFactorResolverImpl {\n    const auth = _castAuth(authExtern);\n    const serverResponse = error.customData._serverResponse;\n    const hints = (serverResponse.mfaInfo || []).map(enrollment =>\n      MultiFactorInfoImpl._fromServerResponse(auth, enrollment)\n    );\n\n    _assert(\n      serverResponse.mfaPendingCredential,\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const session = MultiFactorSessionImpl._fromMfaPendingCredential(\n      serverResponse.mfaPendingCredential\n    );\n\n    return new MultiFactorResolverImpl(\n      session,\n      hints,\n      async (\n        assertion: MultiFactorAssertionImpl\n      ): Promise<UserCredentialInternal> => {\n        const mfaResponse = await assertion._process(auth, session);\n        // Clear out the unneeded fields from the old login response\n        delete serverResponse.mfaInfo;\n        delete serverResponse.mfaPendingCredential;\n\n        // Use in the new token & refresh token in the old response\n        const idTokenResponse = {\n          ...serverResponse,\n          idToken: mfaResponse.idToken,\n          refreshToken: mfaResponse.refreshToken\n        };\n\n        // TODO: we should collapse this switch statement into UserCredentialImpl._forOperation and have it support the SIGN_IN case\n        switch (error.operationType) {\n          case OperationType.SIGN_IN:\n            const userCredential =\n              await UserCredentialImpl._fromIdTokenResponse(\n                auth,\n                error.operationType,\n                idTokenResponse\n              );\n            await auth._updateCurrentUser(userCredential.user);\n            return userCredential;\n          case OperationType.REAUTHENTICATE:\n            _assert(error.user, auth, AuthErrorCode.INTERNAL_ERROR);\n            return UserCredentialImpl._forOperation(\n              error.user,\n              error.operationType,\n              idTokenResponse\n            );\n          default:\n            _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n        }\n      }\n    );\n  }\n\n  async resolveSignIn(\n    assertionExtern: MultiFactorAssertionImpl\n  ): Promise<UserCredential> {\n    const assertion = assertionExtern as MultiFactorAssertionImpl;\n    return this.signInResolver(assertion);\n  }\n}\n\n/**\n * Provides a {@link MultiFactorResolver} suitable for completion of a\n * multi-factor flow.\n *\n * @param auth - The {@link Auth} instance.\n * @param error - The {@link MultiFactorError} raised during a sign-in, or\n * reauthentication operation.\n *\n * @public\n */\nexport function getMultiFactorResolver(\n  auth: Auth,\n  error: MultiFactorError\n): MultiFactorResolver {\n  const authModular = getModularInstance(auth);\n  const errorInternal = error as MultiFactorErrorInternal;\n  _assert(\n    error.customData.operationType,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\n  _assert(\n    errorInternal.customData._serverResponse?.mfaPendingCredential,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\n\n  return MultiFactorResolverImpl._fromError(authModular, errorInternal);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { SignInWithPhoneNumberRequest } from '../authentication/sms';\nimport { FinalizeMfaResponse } from '../authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\n\n/**\n * MFA Info as returned by the API.\n */\ninterface BaseMfaEnrollment {\n  mfaEnrollmentId: string;\n  enrolledAt: number;\n  displayName?: string;\n}\n\n/**\n * An MFA provided by SMS verification.\n */\nexport interface PhoneMfaEnrollment extends BaseMfaEnrollment {\n  phoneInfo: string;\n}\n\n/**\n * An MFA provided by TOTP (Time-based One Time Password).\n */\nexport interface TotpMfaEnrollment extends BaseMfaEnrollment {}\n\n/**\n * MfaEnrollment can be any subtype of BaseMfaEnrollment, currently only PhoneMfaEnrollment and TotpMfaEnrollment are supported.\n */\nexport type MfaEnrollment = PhoneMfaEnrollment | TotpMfaEnrollment;\n\nexport interface StartPhoneMfaEnrollmentRequest {\n  idToken: string;\n  phoneEnrollmentInfo: {\n    phoneNumber: string;\n    // reCAPTCHA v2 token\n    recaptchaToken?: string;\n    // reCAPTCHA Enterprise token\n    captchaResponse?: string;\n    clientType?: RecaptchaClientType;\n    recaptchaVersion?: RecaptchaVersion;\n  };\n  tenantId?: string;\n}\n\nexport interface StartPhoneMfaEnrollmentResponse {\n  phoneSessionInfo: {\n    sessionInfo: string;\n  };\n}\n\nexport function startEnrollPhoneMfa(\n  auth: AuthInternal,\n  request: StartPhoneMfaEnrollmentRequest\n): Promise<StartPhoneMfaEnrollmentResponse> {\n  return _performApiRequest<\n    StartPhoneMfaEnrollmentRequest,\n    StartPhoneMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface FinalizePhoneMfaEnrollmentRequest {\n  idToken: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  displayName?: string | null;\n  tenantId?: string;\n}\n\nexport interface FinalizePhoneMfaEnrollmentResponse\n  extends FinalizeMfaResponse {}\n\nexport function finalizeEnrollPhoneMfa(\n  auth: AuthInternal,\n  request: FinalizePhoneMfaEnrollmentRequest\n): Promise<FinalizePhoneMfaEnrollmentResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaEnrollmentRequest,\n    FinalizePhoneMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\nexport interface StartTotpMfaEnrollmentRequest {\n  idToken: string;\n  totpEnrollmentInfo: {};\n  tenantId?: string;\n}\n\nexport interface StartTotpMfaEnrollmentResponse {\n  totpSessionInfo: {\n    sharedSecretKey: string;\n    verificationCodeLength: number;\n    hashingAlgorithm: string;\n    periodSec: number;\n    sessionInfo: string;\n    finalizeEnrollmentTime: number;\n  };\n}\n\nexport function startEnrollTotpMfa(\n  auth: AuthInternal,\n  request: StartTotpMfaEnrollmentRequest\n): Promise<StartTotpMfaEnrollmentResponse> {\n  return _performApiRequest<\n    StartTotpMfaEnrollmentRequest,\n    StartTotpMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface TotpVerificationInfo {\n  sessionInfo: string;\n  verificationCode: string;\n}\nexport interface FinalizeTotpMfaEnrollmentRequest {\n  idToken: string;\n  totpVerificationInfo: TotpVerificationInfo;\n  displayName?: string | null;\n  tenantId?: string;\n}\n\nexport interface FinalizeTotpMfaEnrollmentResponse\n  extends FinalizeMfaResponse {}\n\nexport function finalizeEnrollTotpMfa(\n  auth: AuthInternal,\n  request: FinalizeTotpMfaEnrollmentRequest\n): Promise<FinalizeTotpMfaEnrollmentResponse> {\n  return _performApiRequest<\n    FinalizeTotpMfaEnrollmentRequest,\n    FinalizeTotpMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface WithdrawMfaRequest {\n  idToken: string;\n  mfaEnrollmentId: string;\n  tenantId?: string;\n}\n\nexport interface WithdrawMfaResponse extends FinalizeMfaResponse {}\n\nexport function withdrawMfa(\n  auth: AuthInternal,\n  request: WithdrawMfaRequest\n): Promise<WithdrawMfaResponse> {\n  return _performApiRequest<WithdrawMfaRequest, WithdrawMfaResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.WITHDRAW_MFA,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  MultiFactorAssertion,\n  MultiFactorInfo,\n  MultiFactorSession,\n  MultiFactorUser,\n  User\n} from '../model/public_types';\n\nimport { withdrawMfa } from '../api/account_management/mfa';\nimport { _logoutIfInvalidated } from '../core/user/invalidation';\nimport { UserInternal } from '../model/user';\nimport { MultiFactorAssertionImpl } from './mfa_assertion';\nimport { MultiFactorInfoImpl } from './mfa_info';\nimport { MultiFactorSessionImpl } from './mfa_session';\nimport { getModularInstance } from '@firebase/util';\n\nexport class MultiFactorUserImpl implements MultiFactorUser {\n  enrolledFactors: MultiFactorInfo[] = [];\n\n  private constructor(readonly user: UserInternal) {\n    user._onReload(userInfo => {\n      if (userInfo.mfaInfo) {\n        this.enrolledFactors = userInfo.mfaInfo.map(enrollment =>\n          MultiFactorInfoImpl._fromServerResponse(user.auth, enrollment)\n        );\n      }\n    });\n  }\n\n  static _fromUser(user: UserInternal): MultiFactorUserImpl {\n    return new MultiFactorUserImpl(user);\n  }\n\n  async getSession(): Promise<MultiFactorSession> {\n    return MultiFactorSessionImpl._fromIdtoken(\n      await this.user.getIdToken(),\n      this.user\n    );\n  }\n\n  async enroll(\n    assertionExtern: MultiFactorAssertion,\n    displayName?: string | null\n  ): Promise<void> {\n    const assertion = assertionExtern as MultiFactorAssertionImpl;\n    const session = (await this.getSession()) as MultiFactorSessionImpl;\n    const finalizeMfaResponse = await _logoutIfInvalidated(\n      this.user,\n      assertion._process(this.user.auth, session, displayName)\n    );\n    // New tokens will be issued after enrollment of the new second factors.\n    // They need to be updated on the user.\n    await this.user._updateTokensIfNecessary(finalizeMfaResponse);\n    // The user needs to be reloaded to get the new multi-factor information\n    // from server. USER_RELOADED event will be triggered and `enrolledFactors`\n    // will be updated.\n    return this.user.reload();\n  }\n\n  async unenroll(infoOrUid: MultiFactorInfo | string): Promise<void> {\n    const mfaEnrollmentId =\n      typeof infoOrUid === 'string' ? infoOrUid : infoOrUid.uid;\n    const idToken = await this.user.getIdToken();\n    try {\n      const idTokenResponse = await _logoutIfInvalidated(\n        this.user,\n        withdrawMfa(this.user.auth, {\n          idToken,\n          mfaEnrollmentId\n        })\n      );\n      // Remove the second factor from the user's list.\n      this.enrolledFactors = this.enrolledFactors.filter(\n        ({ uid }) => uid !== mfaEnrollmentId\n      );\n      // Depending on whether the backend decided to revoke the user's session,\n      // the tokenResponse may be empty. If the tokens were not updated (and they\n      // are now invalid), reloading the user will discover this and invalidate\n      // the user's state accordingly.\n      await this.user._updateTokensIfNecessary(idTokenResponse);\n      await this.user.reload();\n    } catch (e) {\n      throw e;\n    }\n  }\n}\n\nconst multiFactorUserCache = new WeakMap<User, MultiFactorUser>();\n\n/**\n * The {@link MultiFactorUser} corresponding to the user.\n *\n * @remarks\n * This is used to access all multi-factor properties and operations related to the user.\n *\n * @param user - The user.\n *\n * @public\n */\nexport function multiFactor(user: User): MultiFactorUser {\n  const userModular = getModularInstance(user);\n  if (!multiFactorUserCache.has(userModular)) {\n    multiFactorUserCache.set(\n      userModular,\n      MultiFactorUserImpl._fromUser(userModular as UserInternal)\n    );\n  }\n  return multiFactorUserCache.get(userModular)!;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Unsubscribe } from '@firebase/util';\nimport { FirebaseAuthInternal } from '@firebase/auth-interop-types';\n\nimport { AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { _assert } from '../util/assert';\nimport { AuthErrorCode } from '../errors';\n\ninterface TokenListener {\n  (tok: string | null): unknown;\n}\n\nexport class AuthInterop implements FirebaseAuthInternal {\n  private readonly internalListeners: Map<TokenListener, Unsubscribe> =\n    new Map();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  getUid(): string | null {\n    this.assertAuthConfigured();\n    return this.auth.currentUser?.uid || null;\n  }\n\n  async getToken(\n    forceRefresh?: boolean\n  ): Promise<{ accessToken: string } | null> {\n    this.assertAuthConfigured();\n    await this.auth._initializationPromise;\n    if (!this.auth.currentUser) {\n      return null;\n    }\n\n    const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);\n    return { accessToken };\n  }\n\n  addAuthTokenListener(listener: TokenListener): void {\n    this.assertAuthConfigured();\n    if (this.internalListeners.has(listener)) {\n      return;\n    }\n\n    const unsubscribe = this.auth.onIdTokenChanged(user => {\n      listener(\n        (user as UserInternal | null)?.stsTokenManager.accessToken || null\n      );\n    });\n    this.internalListeners.set(listener, unsubscribe);\n    this.updateProactiveRefresh();\n  }\n\n  removeAuthTokenListener(listener: TokenListener): void {\n    this.assertAuthConfigured();\n    const unsubscribe = this.internalListeners.get(listener);\n    if (!unsubscribe) {\n      return;\n    }\n\n    this.internalListeners.delete(listener);\n    unsubscribe();\n    this.updateProactiveRefresh();\n  }\n\n  private assertAuthConfigured(): void {\n    _assert(\n      this.auth._initializationPromise,\n      AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH\n    );\n  }\n\n  private updateProactiveRefresh(): void {\n    if (this.internalListeners.size > 0) {\n      this.auth._startProactiveRefresh();\n    } else {\n      this.auth._stopProactiveRefresh();\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _registerComponent, registerVersion } from '@firebase/app';\nimport {\n  Component,\n  ComponentType,\n  InstantiationMode\n} from '@firebase/component';\n\nimport { name, version } from '../../../package.json';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _getClientVersion, ClientPlatform } from '../util/version';\nimport { _castAuth, AuthImpl, DefaultConfig } from './auth_impl';\nimport { AuthInterop } from './firebase_internal';\nimport { ConfigInternal } from '../../model/auth';\nimport { Dependencies } from '../../model/public_types';\nimport { _initializeAuthInstance } from './initialize';\n\nexport const enum _ComponentName {\n  AUTH = 'auth',\n  AUTH_INTERNAL = 'auth-internal'\n}\n\nfunction getVersionForPlatform(\n  clientPlatform: ClientPlatform\n): string | undefined {\n  switch (clientPlatform) {\n    case ClientPlatform.NODE:\n      return 'node';\n    case ClientPlatform.REACT_NATIVE:\n      return 'rn';\n    case ClientPlatform.WORKER:\n      return 'webworker';\n    case ClientPlatform.CORDOVA:\n      return 'cordova';\n    case ClientPlatform.WEB_EXTENSION:\n      return 'web-extension';\n    default:\n      return undefined;\n  }\n}\n\n/** @internal */\nexport function registerAuth(clientPlatform: ClientPlatform): void {\n  _registerComponent(\n    new Component(\n      _ComponentName.AUTH,\n      (container, { options: deps }: { options?: Dependencies }) => {\n        const app = container.getProvider('app').getImmediate()!;\n        const heartbeatServiceProvider =\n          container.getProvider<'heartbeat'>('heartbeat');\n        const appCheckServiceProvider =\n          container.getProvider<'app-check-internal'>('app-check-internal');\n        const { apiKey, authDomain } = app.options;\n\n        _assert(\n          apiKey && !apiKey.includes(':'),\n          AuthErrorCode.INVALID_API_KEY,\n          { appName: app.name }\n        );\n\n        const config: ConfigInternal = {\n          apiKey,\n          authDomain,\n          clientPlatform,\n          apiHost: DefaultConfig.API_HOST,\n          tokenApiHost: DefaultConfig.TOKEN_API_HOST,\n          apiScheme: DefaultConfig.API_SCHEME,\n          sdkClientVersion: _getClientVersion(clientPlatform)\n        };\n\n        const authInstance = new AuthImpl(\n          app,\n          heartbeatServiceProvider,\n          appCheckServiceProvider,\n          config\n        );\n        _initializeAuthInstance(authInstance, deps);\n\n        return authInstance;\n      },\n      ComponentType.PUBLIC\n    )\n      /**\n       * Auth can only be initialized by explicitly calling getAuth() or initializeAuth()\n       * For why we do this, See go/firebase-next-auth-init\n       */\n      .setInstantiationMode(InstantiationMode.EXPLICIT)\n      /**\n       * Because all firebase products that depend on auth depend on auth-internal directly,\n       * we need to initialize auth-internal after auth is initialized to make it available to other firebase products.\n       */\n      .setInstanceCreatedCallback(\n        (container, _instanceIdentifier, _instance) => {\n          const authInternalProvider = container.getProvider(\n            _ComponentName.AUTH_INTERNAL\n          );\n          authInternalProvider.initialize();\n        }\n      )\n  );\n\n  _registerComponent(\n    new Component(\n      _ComponentName.AUTH_INTERNAL,\n      container => {\n        const auth = _castAuth(\n          container.getProvider(_ComponentName.AUTH).getImmediate()!\n        );\n        return (auth => new AuthInterop(auth))(auth);\n      },\n      ComponentType.PRIVATE\n    ).setInstantiationMode(InstantiationMode.EXPLICIT)\n  );\n\n  registerVersion(name, version, getVersionForPlatform(clientPlatform));\n  // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../core/errors';\nimport { _createError } from '../core/util/assert';\n\nimport { FirebaseApp, getApp, _getProvider } from '@firebase/app';\nimport { Auth } from '../model/public_types';\n\nimport { initializeAuth, inMemoryPersistence, connectAuthEmulator } from '..';\nimport { registerAuth } from '../core/auth/register';\nimport { ClientPlatform } from '../core/util/version';\nimport { AuthImpl } from '../core/auth/auth_impl';\n\nimport { FetchProvider } from '../core/util/fetch_provider';\nimport { getDefaultEmulatorHost } from '@firebase/util';\n\n// Initialize the fetch polyfill, the types are slightly off so just cast and hope for the best\nFetchProvider.initialize(fetch, Headers, Response);\n\n// First, we set up the various platform-specific features for Node (register\n// the version and declare the Node getAuth function)\n\nexport function getAuth(app: FirebaseApp = getApp()): Auth {\n  const provider = _getProvider(app, 'auth');\n\n  if (provider.isInitialized()) {\n    return provider.getImmediate();\n  }\n\n  const auth = initializeAuth(app);\n\n  const authEmulatorHost = getDefaultEmulatorHost('auth');\n  if (authEmulatorHost) {\n    connectAuthEmulator(auth, `http://${authEmulatorHost}`);\n  }\n\n  return auth;\n}\n\nregisterAuth(ClientPlatform.NODE);\n\n// The rest of this file contains no-ops and errors for browser-specific\n// methods. We keep the browser and Node entry points the same, but features\n// that only work in browsers are set to either do nothing (setPersistence) or\n// to reject with an auth/operation-not-supported-in-this-environment error.\n// The below exports are pulled into the main entry point by a rollup alias\n// plugin (overwriting the default browser imports).\n\n/** auth/operation-not-supported-in-this-environment */\nconst NOT_AVAILABLE_ERROR = _createError(AuthErrorCode.OPERATION_NOT_SUPPORTED);\n\n/** Reject with auth/operation-not-supported-in-this-environment */\nasync function fail(): Promise<void> {\n  throw NOT_AVAILABLE_ERROR;\n}\n\n/**\n * A class which will throw with\n * auth/operation-not-supported-in-this-environment if instantiated\n */\nclass FailClass {\n  constructor() {\n    throw NOT_AVAILABLE_ERROR;\n  }\n}\n\nexport const browserLocalPersistence = inMemoryPersistence;\nexport const browserSessionPersistence = inMemoryPersistence;\nexport const browserCookiePersistence = inMemoryPersistence;\nexport const indexedDBLocalPersistence = inMemoryPersistence;\nexport const browserPopupRedirectResolver = NOT_AVAILABLE_ERROR;\nexport const PhoneAuthProvider = FailClass;\nexport const signInWithPhoneNumber = fail;\nexport const linkWithPhoneNumber = fail;\nexport const reauthenticateWithPhoneNumber = fail;\nexport const updatePhoneNumber = fail;\nexport const signInWithPopup = fail;\nexport const linkWithPopup = fail;\nexport const reauthenticateWithPopup = fail;\nexport const signInWithRedirect = fail;\nexport const linkWithRedirect = fail;\nexport const reauthenticateWithRedirect = fail;\nexport const getRedirectResult = fail;\nexport const RecaptchaVerifier = FailClass;\nexport const initializeRecaptchaConfig = fail;\nexport class PhoneMultiFactorGenerator {\n  static assertion(): unknown {\n    throw NOT_AVAILABLE_ERROR;\n  }\n}\n\n// Set persistence should no-op instead of fail. Changing the prototype will\n// make sure both setPersistence(auth, persistence) and\n// auth.setPersistence(persistence) are covered.\nAuthImpl.prototype.setPersistence = async (): Promise<void> => {};\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performApiRequest,\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary\n} from '../index';\nimport { Auth } from '../../model/public_types';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { MfaEnrollment } from '../account_management/mfa';\nimport { SignInWithIdpResponse } from './idp';\nimport {\n  SignInWithPhoneNumberRequest,\n  SignInWithPhoneNumberResponse\n} from './sms';\n\nexport interface FinalizeMfaResponse {\n  idToken: string;\n  refreshToken: string;\n}\n\n/**\n * @internal\n */\nexport interface IdTokenMfaResponse extends IdTokenResponse {\n  mfaPendingCredential?: string;\n  mfaInfo?: MfaEnrollment[];\n}\n\nexport interface StartPhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  mfaEnrollmentId: string;\n  phoneSignInInfo: {\n    // reCAPTCHA v2 token\n    recaptchaToken?: string;\n    // reCAPTCHA Enterprise token\n    captchaResponse?: string;\n    clientType?: RecaptchaClientType;\n    recaptchaVersion?: RecaptchaVersion;\n  };\n  tenantId?: string;\n}\n\nexport interface StartPhoneMfaSignInResponse {\n  phoneResponseInfo: {\n    sessionInfo: string;\n  };\n}\n\nexport function startSignInPhoneMfa(\n  auth: Auth,\n  request: StartPhoneMfaSignInRequest\n): Promise<StartPhoneMfaSignInResponse> {\n  return _performApiRequest<\n    StartPhoneMfaSignInRequest,\n    StartPhoneMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface FinalizePhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  tenantId?: string;\n}\n\n// TOTP MFA Sign in only has a finalize phase. Phone MFA has a start phase to initiate sending an\n// SMS and a finalize phase to complete sign in. With TOTP, the user already has the OTP in the\n// TOTP/Authenticator app.\nexport interface FinalizeTotpMfaSignInRequest {\n  mfaPendingCredential: string;\n  totpVerificationInfo: { verificationCode: string };\n  tenantId?: string;\n  mfaEnrollmentId: string;\n}\n\nexport interface FinalizePhoneMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport interface FinalizeTotpMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport function finalizeSignInPhoneMfa(\n  auth: Auth,\n  request: FinalizePhoneMfaSignInRequest\n): Promise<FinalizePhoneMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaSignInRequest,\n    FinalizePhoneMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport function finalizeSignInTotpMfa(\n  auth: Auth,\n  request: FinalizeTotpMfaSignInRequest\n): Promise<FinalizeTotpMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizeTotpMfaSignInRequest,\n    FinalizeTotpMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\n/**\n * @internal\n */\nexport type PhoneOrOauthTokenResponse =\n  | SignInWithPhoneNumberResponse\n  | SignInWithIdpResponse\n  | IdTokenResponse;\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { FactorId, MultiFactorAssertion } from '../model/public_types';\nimport { debugFail } from '../core/util/assert';\nimport { MultiFactorSessionImpl, MultiFactorSessionType } from './mfa_session';\nimport { FinalizeMfaResponse } from '../api/authentication/mfa';\nimport { AuthInternal } from '../model/auth';\n\nexport abstract class MultiFactorAssertionImpl implements MultiFactorAssertion {\n  protected constructor(readonly factorId: FactorId) {}\n\n  _process(\n    auth: AuthInternal,\n    session: MultiFactorSessionImpl,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse> {\n    switch (session.type) {\n      case MultiFactorSessionType.ENROLL:\n        return this._finalizeEnroll(auth, session.credential, displayName);\n      case MultiFactorSessionType.SIGN_IN:\n        return this._finalizeSignIn(auth, session.credential);\n      default:\n        return debugFail('unexpected MultiFactorSessionType');\n    }\n  }\n\n  abstract _finalizeEnroll(\n    auth: AuthInternal,\n    idToken: string,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse>;\n  abstract _finalizeSignIn(\n    auth: AuthInternal,\n    mfaPendingCredential: string\n  ): Promise<FinalizeMfaResponse>;\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  TotpMultiFactorAssertion,\n  MultiFactorSession,\n  FactorId\n} from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  finalizeEnrollTotpMfa,\n  startEnrollTotpMfa,\n  StartTotpMfaEnrollmentResponse,\n  TotpVerificationInfo\n} from '../../api/account_management/mfa';\nimport {\n  FinalizeMfaResponse,\n  finalizeSignInTotpMfa\n} from '../../api/authentication/mfa';\nimport { MultiFactorAssertionImpl } from '../../mfa/mfa_assertion';\nimport { MultiFactorSessionImpl } from '../mfa_session';\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\n\n/**\n * Provider for generating a {@link TotpMultiFactorAssertion}.\n *\n * @public\n */\nexport class TotpMultiFactorGenerator {\n  /**\n   * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of\n   * the TOTP (time-based one-time password) second factor.\n   * This assertion is used to complete enrollment in TOTP second factor.\n   *\n   * @param secret A {@link TotpSecret} containing the shared secret key and other TOTP parameters.\n   * @param oneTimePassword One-time password from TOTP App.\n   * @returns A {@link TotpMultiFactorAssertion} which can be used with\n   * {@link MultiFactorUser.enroll}.\n   */\n  static assertionForEnrollment(\n    secret: TotpSecret,\n    oneTimePassword: string\n  ): TotpMultiFactorAssertion {\n    return TotpMultiFactorAssertionImpl._fromSecret(secret, oneTimePassword);\n  }\n\n  /**\n   * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of the TOTP second factor.\n   * This assertion is used to complete signIn with TOTP as the second factor.\n   *\n   * @param enrollmentId identifies the enrolled TOTP second factor.\n   * @param oneTimePassword One-time password from TOTP App.\n   * @returns A {@link TotpMultiFactorAssertion} which can be used with\n   * {@link MultiFactorResolver.resolveSignIn}.\n   */\n  static assertionForSignIn(\n    enrollmentId: string,\n    oneTimePassword: string\n  ): TotpMultiFactorAssertion {\n    return TotpMultiFactorAssertionImpl._fromEnrollmentId(\n      enrollmentId,\n      oneTimePassword\n    );\n  }\n\n  /**\n   * Returns a promise to {@link TotpSecret} which contains the TOTP shared secret key and other parameters.\n   * Creates a TOTP secret as part of enrolling a TOTP second factor.\n   * Used for generating a QR code URL or inputting into a TOTP app.\n   * This method uses the auth instance corresponding to the user in the multiFactorSession.\n   *\n   * @param session The {@link MultiFactorSession} that the user is part of.\n   * @returns A promise to {@link TotpSecret}.\n   */\n  static async generateSecret(\n    session: MultiFactorSession\n  ): Promise<TotpSecret> {\n    const mfaSession = session as MultiFactorSessionImpl;\n    _assert(\n      typeof mfaSession.user?.auth !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const response = await startEnrollTotpMfa(mfaSession.user.auth, {\n      idToken: mfaSession.credential,\n      totpEnrollmentInfo: {}\n    });\n    return TotpSecret._fromStartTotpMfaEnrollmentResponse(\n      response,\n      mfaSession.user.auth\n    );\n  }\n\n  /**\n   * The identifier of the TOTP second factor: `totp`.\n   */\n  static FACTOR_ID: 'totp' = FactorId.TOTP;\n}\n\nexport class TotpMultiFactorAssertionImpl\n  extends MultiFactorAssertionImpl\n  implements TotpMultiFactorAssertion\n{\n  constructor(\n    readonly otp: string,\n    readonly enrollmentId?: string,\n    readonly secret?: TotpSecret\n  ) {\n    super(FactorId.TOTP);\n  }\n\n  /** @internal */\n  static _fromSecret(\n    secret: TotpSecret,\n    otp: string\n  ): TotpMultiFactorAssertionImpl {\n    return new TotpMultiFactorAssertionImpl(otp, undefined, secret);\n  }\n\n  /** @internal */\n  static _fromEnrollmentId(\n    enrollmentId: string,\n    otp: string\n  ): TotpMultiFactorAssertionImpl {\n    return new TotpMultiFactorAssertionImpl(otp, enrollmentId);\n  }\n\n  /** @internal */\n  async _finalizeEnroll(\n    auth: AuthInternal,\n    idToken: string,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse> {\n    _assert(\n      typeof this.secret !== 'undefined',\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    return finalizeEnrollTotpMfa(auth, {\n      idToken,\n      displayName,\n      totpVerificationInfo: this.secret._makeTotpVerificationInfo(this.otp)\n    });\n  }\n\n  /** @internal */\n  async _finalizeSignIn(\n    auth: AuthInternal,\n    mfaPendingCredential: string\n  ): Promise<FinalizeMfaResponse> {\n    _assert(\n      this.enrollmentId !== undefined && this.otp !== undefined,\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    const totpVerificationInfo = { verificationCode: this.otp };\n    return finalizeSignInTotpMfa(auth, {\n      mfaPendingCredential,\n      mfaEnrollmentId: this.enrollmentId,\n      totpVerificationInfo\n    });\n  }\n}\n\n/**\n * Provider for generating a {@link TotpMultiFactorAssertion}.\n *\n * Stores the shared secret key and other parameters to generate time-based OTPs.\n * Implements methods to retrieve the shared secret key and generate a QR code URL.\n * @public\n */\nexport class TotpSecret {\n  /**\n   * Shared secret key/seed used for enrolling in TOTP MFA and generating OTPs.\n   */\n  readonly secretKey: string;\n  /**\n   * Hashing algorithm used.\n   */\n  readonly hashingAlgorithm: string;\n  /**\n   * Length of the one-time passwords to be generated.\n   */\n  readonly codeLength: number;\n  /**\n   * The interval (in seconds) when the OTP codes should change.\n   */\n  readonly codeIntervalSeconds: number;\n  /**\n   * The timestamp (UTC string) by which TOTP enrollment should be completed.\n   */\n  // This can be used by callers to show a countdown of when to enter OTP code by.\n  readonly enrollmentCompletionDeadline: string;\n\n  // The public members are declared outside the constructor so the docs can be generated.\n  private constructor(\n    secretKey: string,\n    hashingAlgorithm: string,\n    codeLength: number,\n    codeIntervalSeconds: number,\n    enrollmentCompletionDeadline: string,\n    private readonly sessionInfo: string,\n    private readonly auth: AuthInternal\n  ) {\n    this.secretKey = secretKey;\n    this.hashingAlgorithm = hashingAlgorithm;\n    this.codeLength = codeLength;\n    this.codeIntervalSeconds = codeIntervalSeconds;\n    this.enrollmentCompletionDeadline = enrollmentCompletionDeadline;\n  }\n\n  /** @internal */\n  static _fromStartTotpMfaEnrollmentResponse(\n    response: StartTotpMfaEnrollmentResponse,\n    auth: AuthInternal\n  ): TotpSecret {\n    return new TotpSecret(\n      response.totpSessionInfo.sharedSecretKey,\n      response.totpSessionInfo.hashingAlgorithm,\n      response.totpSessionInfo.verificationCodeLength,\n      response.totpSessionInfo.periodSec,\n      new Date(response.totpSessionInfo.finalizeEnrollmentTime).toUTCString(),\n      response.totpSessionInfo.sessionInfo,\n      auth\n    );\n  }\n\n  /** @internal */\n  _makeTotpVerificationInfo(otp: string): TotpVerificationInfo {\n    return { sessionInfo: this.sessionInfo, verificationCode: otp };\n  }\n\n  /**\n   * Returns a QR code URL as described in\n   * https://github.com/google/google-authenticator/wiki/Key-Uri-Format\n   * This can be displayed to the user as a QR code to be scanned into a TOTP app like Google Authenticator.\n   * If the optional parameters are unspecified, an accountName of <userEmail> and issuer of <firebaseAppName> are used.\n   *\n   * @param accountName the name of the account/app along with a user identifier.\n   * @param issuer issuer of the TOTP (likely the app name).\n   * @returns A QR code URL string.\n   */\n  generateQrCodeUrl(accountName?: string, issuer?: string): string {\n    let useDefaults = false;\n    if (_isEmptyString(accountName) || _isEmptyString(issuer)) {\n      useDefaults = true;\n    }\n    if (useDefaults) {\n      if (_isEmptyString(accountName)) {\n        accountName = this.auth.currentUser?.email || 'unknownuser';\n      }\n      if (_isEmptyString(issuer)) {\n        issuer = this.auth.name;\n      }\n    }\n    return `otpauth://totp/${issuer}:${accountName}?secret=${this.secretKey}&issuer=${issuer}&algorithm=${this.hashingAlgorithm}&digits=${this.codeLength}`;\n  }\n}\n\n/** @internal */\nfunction _isEmptyString(input?: string): boolean {\n  return typeof input === 'undefined' || input?.length === 0;\n}\n", "export { A as ActionCodeOperation, aj as ActionCodeURL, M as AuthCredential, J as AuthErrorCodes, N as EmailAuthCredential, W as EmailAuthProvider, X as FacebookAuthProvider, F as FactorId, Z as GithubAuthProvider, Y as GoogleAuthProvider, Q as OAuthCredential, _ as OAuthProvider, O as OperationType, U as PhoneAuthCredential, P as PhoneAuthProvider, n as PhoneMultiFactorGenerator, q as ProviderId, R as RecaptchaVerifier, $ as SAMLAuthProvider, S as SignInMethod, T as TotpMultiFactorGenerator, o as TotpSecret, a0 as TwitterAuthProvider, a8 as applyActionCode, y as beforeAuthStateChanged, a as browserCookiePersistence, b as browserLocalPersistence, m as browserPopupRedirectResolver, c as browserSessionPersistence, a9 as checkActionCode, a7 as confirmPasswordReset, L as connectAuthEmulator, ab as createUserWithEmailAndPassword, H as debugErrorMap, G as deleteUser, ag as fetchSignInMethodsForEmail, ar as getAdditionalUserInfo, p as getAuth, ao as getIdToken, ap as getIdTokenResult, at as getMultiFactorResolver, k as getRedirectResult, V as inMemoryPersistence, i as indexedDBLocalPersistence, K as initializeAuth, v as initializeRecaptchaConfig, ae as isSignInWithEmailLink, a3 as linkWithCredential, l as linkWithPhoneNumber, e as linkWithPopup, h as linkWithRedirect, au as multiFactor, z as onAuthStateChanged, x as onIdTokenChanged, ak as parseActionCodeURL, I as prodErrorMap, a4 as reauthenticateWithCredential, r as reauthenticateWithPhoneNumber, f as reauthenticateWithPopup, j as reauthenticateWithRedirect, as as reload, E as revokeAccessToken, ah as sendEmailVerification, a6 as sendPasswordResetEmail, ad as sendSignInLinkToEmail, t as setPersistence, a1 as signInAnonymously, a2 as signInWithCredential, a5 as signInWithCustomToken, ac as signInWithEmailAndPassword, af as signInWithEmailLink, s as signInWithPhoneNumber, d as signInWithPopup, g as signInWithRedirect, D as signOut, aq as unlink, C as updateCurrentUser, am as updateEmail, an as updatePassword, u as updatePhoneNumber, al as updateProfile, B as useDeviceLanguage, w as validatePassword, ai as verifyBeforeUpdateEmail, aa as verifyPasswordResetCode } from './totp-c8d207b9.js';\nimport '@firebase/app';\nimport '@firebase/util';\nimport '@firebase/component';\nimport '@firebase/logger';\n//# sourceMappingURL=index.js.map\n", "export * from '@firebase/auth';\n//# sourceMappingURL=index.mjs.map\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst LONG_TYPE = 'type.googleapis.com/google.protobuf.Int64Value';\nconst UNSIGNED_LONG_TYPE = 'type.googleapis.com/google.protobuf.UInt64Value';\n\nfunction mapValues(\n  // { [k: string]: unknown } is no longer a wildcard assignment target after typescript 3.5\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  o: { [key: string]: any },\n  f: (arg0: unknown) => unknown\n): object {\n  const result: { [key: string]: unknown } = {};\n  for (const key in o) {\n    if (o.hasOwnProperty(key)) {\n      result[key] = f(o[key]);\n    }\n  }\n  return result;\n}\n\n/**\n * Takes data and encodes it in a JSON-friendly way, such that types such as\n * Date are preserved.\n * @internal\n * @param data - Data to encode.\n */\nexport function encode(data: unknown): unknown {\n  if (data == null) {\n    return null;\n  }\n  if (data instanceof Number) {\n    data = data.valueOf();\n  }\n  if (typeof data === 'number' && isFinite(data)) {\n    // Any number in JS is safe to put directly in JSON and parse as a double\n    // without any loss of precision.\n    return data;\n  }\n  if (data === true || data === false) {\n    return data;\n  }\n  if (Object.prototype.toString.call(data) === '[object String]') {\n    return data;\n  }\n  if (data instanceof Date) {\n    return data.toISOString();\n  }\n  if (Array.isArray(data)) {\n    return data.map(x => encode(x));\n  }\n  if (typeof data === 'function' || typeof data === 'object') {\n    return mapValues(data!, x => encode(x));\n  }\n  // If we got this far, the data is not encodable.\n  throw new Error('Data cannot be encoded in JSON: ' + data);\n}\n\n/**\n * Takes data that's been encoded in a JSON-friendly form and returns a form\n * with richer datatypes, such as Dates, etc.\n * @internal\n * @param json - JSON to convert.\n */\nexport function decode(json: unknown): unknown {\n  if (json == null) {\n    return json;\n  }\n  if ((json as { [key: string]: unknown })['@type']) {\n    switch ((json as { [key: string]: unknown })['@type']) {\n      case LONG_TYPE:\n      // Fall through and handle this the same as unsigned.\n      case UNSIGNED_LONG_TYPE: {\n        // Technically, this could work return a valid number for malformed\n        // data if there was a number followed by garbage. But it's just not\n        // worth all the extra code to detect that case.\n        const value = Number((json as { [key: string]: unknown })['value']);\n        if (isNaN(value)) {\n          throw new Error('Data cannot be decoded from JSON: ' + json);\n        }\n        return value;\n      }\n      default: {\n        throw new Error('Data cannot be decoded from JSON: ' + json);\n      }\n    }\n  }\n  if (Array.isArray(json)) {\n    return json.map(x => decode(x));\n  }\n  if (typeof json === 'function' || typeof json === 'object') {\n    return mapValues(json!, x => decode(x));\n  }\n  // Anything else is safe to return.\n  return json;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Type constant for Firebase Functions.\n */\nexport const FUNCTIONS_TYPE = 'functions';\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FunctionsErrorCodeCore as FunctionsErrorCode } from './public-types';\nimport { decode } from './serializer';\nimport { HttpResponseBody } from './service';\nimport { FirebaseError } from '@firebase/util';\nimport { FUNCTIONS_TYPE } from './constants';\n\n/**\n * Standard error codes for different ways a request can fail, as defined by:\n * https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto\n *\n * This map is used primarily to convert from a backend error code string to\n * a client SDK error code string, and make sure it's in the supported set.\n */\nconst errorCodeMap: { [name: string]: FunctionsErrorCode } = {\n  OK: 'ok',\n  CANCELLED: 'cancelled',\n  UNKNOWN: 'unknown',\n  INVALID_ARGUMENT: 'invalid-argument',\n  DEADLINE_EXCEEDED: 'deadline-exceeded',\n  NOT_FOUND: 'not-found',\n  ALREADY_EXISTS: 'already-exists',\n  PERMISSION_DENIED: 'permission-denied',\n  UNAUTHENTICATED: 'unauthenticated',\n  RESOURCE_EXHAUSTED: 'resource-exhausted',\n  FAILED_PRECONDITION: 'failed-precondition',\n  ABORTED: 'aborted',\n  OUT_OF_RANGE: 'out-of-range',\n  UNIMPLEMENTED: 'unimplemented',\n  INTERNAL: 'internal',\n  UNAVAILABLE: 'unavailable',\n  DATA_LOSS: 'data-loss'\n};\n\n/**\n * An error returned by the Firebase Functions client SDK.\n *\n * See {@link FunctionsErrorCode} for full documentation of codes.\n *\n * @public\n */\nexport class FunctionsError extends FirebaseError {\n  /**\n   * Constructs a new instance of the `FunctionsError` class.\n   */\n  constructor(\n    /**\n     * A standard error code that will be returned to the client. This also\n     * determines the HTTP status code of the response, as defined in code.proto.\n     */\n    code: FunctionsErrorCode,\n    message?: string,\n    /**\n     * Additional details to be converted to JSON and included in the error response.\n     */\n    readonly details?: unknown\n  ) {\n    super(`${FUNCTIONS_TYPE}/${code}`, message || '');\n\n    // Since the FirebaseError constructor sets the prototype of `this` to FirebaseError.prototype,\n    // we also have to do it in all subclasses to allow for correct `instanceof` checks.\n    Object.setPrototypeOf(this, FunctionsError.prototype);\n  }\n}\n\n/**\n * Takes an HTTP status code and returns the corresponding ErrorCode.\n * This is the standard HTTP status code -> error mapping defined in:\n * https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto\n *\n * @param status An HTTP status code.\n * @return The corresponding ErrorCode, or ErrorCode.UNKNOWN if none.\n */\nfunction codeForHTTPStatus(status: number): FunctionsErrorCode {\n  // Make sure any successful status is OK.\n  if (status >= 200 && status < 300) {\n    return 'ok';\n  }\n  switch (status) {\n    case 0:\n      // This can happen if the server returns 500.\n      return 'internal';\n    case 400:\n      return 'invalid-argument';\n    case 401:\n      return 'unauthenticated';\n    case 403:\n      return 'permission-denied';\n    case 404:\n      return 'not-found';\n    case 409:\n      return 'aborted';\n    case 429:\n      return 'resource-exhausted';\n    case 499:\n      return 'cancelled';\n    case 500:\n      return 'internal';\n    case 501:\n      return 'unimplemented';\n    case 503:\n      return 'unavailable';\n    case 504:\n      return 'deadline-exceeded';\n    default: // ignore\n  }\n  return 'unknown';\n}\n\n/**\n * Takes an HTTP response and returns the corresponding Error, if any.\n */\nexport function _errorForResponse(\n  status: number,\n  bodyJSON: HttpResponseBody | null\n): Error | null {\n  let code = codeForHTTPStatus(status);\n\n  // Start with reasonable defaults from the status code.\n  let description: string = code;\n\n  let details: unknown = undefined;\n\n  // Then look through the body for explicit details.\n  try {\n    const errorJSON = bodyJSON && bodyJSON.error;\n    if (errorJSON) {\n      const status = errorJSON.status;\n      if (typeof status === 'string') {\n        if (!errorCodeMap[status]) {\n          // They must've included an unknown error code in the body.\n          return new FunctionsError('internal', 'internal');\n        }\n        code = errorCodeMap[status];\n\n        // TODO(klimt): Add better default descriptions for error enums.\n        // The default description needs to be updated for the new code.\n        description = status;\n      }\n\n      const message = errorJSON.message;\n      if (typeof message === 'string') {\n        description = message;\n      }\n\n      details = errorJSON.details;\n      if (details !== undefined) {\n        details = decode(details);\n      }\n    }\n  } catch (e) {\n    // If we couldn't parse explicit error data, that's fine.\n  }\n\n  if (code === 'ok') {\n    // Technically, there's an edge case where a developer could explicitly\n    // return an error code of OK, and we will treat it as success, but that\n    // seems reasonable.\n    return null;\n  }\n\n  return new FunctionsError(code, description, details);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Provider } from '@firebase/component';\nimport { _isFirebaseServerApp, FirebaseApp } from '@firebase/app';\nimport {\n  AppCheckInternalComponentName,\n  FirebaseAppCheckInternal\n} from '@firebase/app-check-interop-types';\nimport {\n  MessagingInternal,\n  MessagingInternalComponentName\n} from '@firebase/messaging-interop-types';\nimport {\n  FirebaseAuthInternal,\n  FirebaseAuthInternalName\n} from '@firebase/auth-interop-types';\n\n/**\n * The metadata that should be supplied with function calls.\n * @internal\n */\nexport interface Context {\n  authToken?: string;\n  messagingToken?: string;\n  appCheckToken: string | null;\n}\n\n/**\n * Helper class to get metadata that should be included with a function call.\n * @internal\n */\nexport class ContextProvider {\n  private auth: FirebaseAuthInternal | null = null;\n  private messaging: MessagingInternal | null = null;\n  private appCheck: FirebaseAppCheckInternal | null = null;\n  private serverAppAppCheckToken: string | null = null;\n  constructor(\n    readonly app: FirebaseApp,\n    authProvider: Provider<FirebaseAuthInternalName>,\n    messagingProvider: Provider<MessagingInternalComponentName>,\n    appCheckProvider: Provider<AppCheckInternalComponentName>\n  ) {\n    if (_isFirebaseServerApp(app) && app.settings.appCheckToken) {\n      this.serverAppAppCheckToken = app.settings.appCheckToken;\n    }\n    this.auth = authProvider.getImmediate({ optional: true });\n    this.messaging = messagingProvider.getImmediate({\n      optional: true\n    });\n\n    if (!this.auth) {\n      authProvider.get().then(\n        auth => (this.auth = auth),\n        () => {\n          /* get() never rejects */\n        }\n      );\n    }\n\n    if (!this.messaging) {\n      messagingProvider.get().then(\n        messaging => (this.messaging = messaging),\n        () => {\n          /* get() never rejects */\n        }\n      );\n    }\n\n    if (!this.appCheck) {\n      appCheckProvider?.get().then(\n        appCheck => (this.appCheck = appCheck),\n        () => {\n          /* get() never rejects */\n        }\n      );\n    }\n  }\n\n  async getAuthToken(): Promise<string | undefined> {\n    if (!this.auth) {\n      return undefined;\n    }\n\n    try {\n      const token = await this.auth.getToken();\n      return token?.accessToken;\n    } catch (e) {\n      // If there's any error when trying to get the auth token, leave it off.\n      return undefined;\n    }\n  }\n\n  async getMessagingToken(): Promise<string | undefined> {\n    if (\n      !this.messaging ||\n      !('Notification' in self) ||\n      Notification.permission !== 'granted'\n    ) {\n      return undefined;\n    }\n\n    try {\n      return await this.messaging.getToken();\n    } catch (e) {\n      // We don't warn on this, because it usually means messaging isn't set up.\n      // console.warn('Failed to retrieve instance id token.', e);\n\n      // If there's any error when trying to get the token, leave it off.\n      return undefined;\n    }\n  }\n\n  async getAppCheckToken(\n    limitedUseAppCheckTokens?: boolean\n  ): Promise<string | null> {\n    if (this.serverAppAppCheckToken) {\n      return this.serverAppAppCheckToken;\n    }\n    if (this.appCheck) {\n      const result = limitedUseAppCheckTokens\n        ? await this.appCheck.getLimitedUseToken()\n        : await this.appCheck.getToken();\n      if (result.error) {\n        // Do not send the App Check header to the functions endpoint if\n        // there was an error from the App Check exchange endpoint. The App\n        // Check SDK will already have logged the error to console.\n        return null;\n      }\n      return result.token;\n    }\n    return null;\n  }\n\n  async getContext(limitedUseAppCheckTokens?: boolean): Promise<Context> {\n    const authToken = await this.getAuthToken();\n    const messagingToken = await this.getMessagingToken();\n    const appCheckToken = await this.getAppCheckToken(limitedUseAppCheckTokens);\n    return { authToken, messagingToken, appCheckToken };\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp, _FirebaseService } from '@firebase/app';\nimport {\n  HttpsCallable,\n  HttpsCallableResult,\n  HttpsCallableStreamResult,\n  HttpsCallableOptions,\n  HttpsCallableStreamOptions\n} from './public-types';\nimport { _errorForResponse, FunctionsError } from './error';\nimport { ContextProvider } from './context';\nimport { encode, decode } from './serializer';\nimport { Provider } from '@firebase/component';\nimport { FirebaseAuthInternalName } from '@firebase/auth-interop-types';\nimport { MessagingInternalComponentName } from '@firebase/messaging-interop-types';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\nimport {\n  isCloudWorkstation,\n  pingServer,\n  updateEmulatorBanner\n} from '@firebase/util';\n\nexport const DEFAULT_REGION = 'us-central1';\n\nconst responseLineRE = /^data: (.*?)(?:\\n|$)/;\n\n/**\n * The response to an http request.\n */\ninterface HttpResponse {\n  status: number;\n  json: HttpResponseBody | null;\n}\n/**\n * Describes the shape of the HttpResponse body.\n * It makes functions that would otherwise take {} able to access the\n * possible elements in the body more easily\n */\nexport interface HttpResponseBody {\n  data?: unknown;\n  result?: unknown;\n  error?: {\n    message?: unknown;\n    status?: unknown;\n    details?: unknown;\n  };\n}\n\ninterface CancellablePromise<T> {\n  promise: Promise<T>;\n  cancel: () => void;\n}\n\n/**\n * Returns a Promise that will be rejected after the given duration.\n * The error will be of type FunctionsError.\n *\n * @param millis Number of milliseconds to wait before rejecting.\n */\nfunction failAfter(millis: number): CancellablePromise<never> {\n  // Node timers and browser timers are fundamentally incompatible, but we\n  // don't care about the value here\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let timer: any | null = null;\n  return {\n    promise: new Promise((_, reject) => {\n      timer = setTimeout(() => {\n        reject(new FunctionsError('deadline-exceeded', 'deadline-exceeded'));\n      }, millis);\n    }),\n    cancel: () => {\n      if (timer) {\n        clearTimeout(timer);\n      }\n    }\n  };\n}\n\n/**\n * The main class for the Firebase Functions SDK.\n * @internal\n */\nexport class FunctionsService implements _FirebaseService {\n  readonly contextProvider: ContextProvider;\n  emulatorOrigin: string | null = null;\n  cancelAllRequests: Promise<void>;\n  deleteService!: () => Promise<void>;\n  region: string;\n  customDomain: string | null;\n\n  /**\n   * Creates a new Functions service for the given app.\n   * @param app - The FirebaseApp to use.\n   */\n  constructor(\n    readonly app: FirebaseApp,\n    authProvider: Provider<FirebaseAuthInternalName>,\n    messagingProvider: Provider<MessagingInternalComponentName>,\n    appCheckProvider: Provider<AppCheckInternalComponentName>,\n    regionOrCustomDomain: string = DEFAULT_REGION,\n    readonly fetchImpl: typeof fetch = (...args) => fetch(...args)\n  ) {\n    this.contextProvider = new ContextProvider(\n      app,\n      authProvider,\n      messagingProvider,\n      appCheckProvider\n    );\n    // Cancels all ongoing requests when resolved.\n    this.cancelAllRequests = new Promise(resolve => {\n      this.deleteService = () => {\n        return Promise.resolve(resolve());\n      };\n    });\n\n    // Resolve the region or custom domain overload by attempting to parse it.\n    try {\n      const url = new URL(regionOrCustomDomain);\n      this.customDomain =\n        url.origin + (url.pathname === '/' ? '' : url.pathname);\n      this.region = DEFAULT_REGION;\n    } catch (e) {\n      this.customDomain = null;\n      this.region = regionOrCustomDomain;\n    }\n  }\n\n  _delete(): Promise<void> {\n    return this.deleteService();\n  }\n\n  /**\n   * Returns the URL for a callable with the given name.\n   * @param name - The name of the callable.\n   * @internal\n   */\n  _url(name: string): string {\n    const projectId = this.app.options.projectId;\n    if (this.emulatorOrigin !== null) {\n      const origin = this.emulatorOrigin;\n      return `${origin}/${projectId}/${this.region}/${name}`;\n    }\n\n    if (this.customDomain !== null) {\n      return `${this.customDomain}/${name}`;\n    }\n\n    return `https://${this.region}-${projectId}.cloudfunctions.net/${name}`;\n  }\n}\n\n/**\n * Modify this instance to communicate with the Cloud Functions emulator.\n *\n * Note: this must be called before this instance has been used to do any operations.\n *\n * @param host The emulator host (ex: localhost)\n * @param port The emulator port (ex: 5001)\n * @public\n */\nexport function connectFunctionsEmulator(\n  functionsInstance: FunctionsService,\n  host: string,\n  port: number\n): void {\n  const useSsl = isCloudWorkstation(host);\n  functionsInstance.emulatorOrigin = `http${\n    useSsl ? 's' : ''\n  }://${host}:${port}`;\n  // Workaround to get cookies in Firebase Studio\n  if (useSsl) {\n    void pingServer(functionsInstance.emulatorOrigin + '/backends');\n    updateEmulatorBanner('Functions', true);\n  }\n}\n\n/**\n * Returns a reference to the callable https trigger with the given name.\n * @param name - The name of the trigger.\n * @public\n */\nexport function httpsCallable<RequestData, ResponseData, StreamData = unknown>(\n  functionsInstance: FunctionsService,\n  name: string,\n  options?: HttpsCallableOptions\n): HttpsCallable<RequestData, ResponseData, StreamData> {\n  const callable = (\n    data?: RequestData | null\n  ): Promise<HttpsCallableResult> => {\n    return call(functionsInstance, name, data, options || {});\n  };\n\n  callable.stream = (\n    data?: RequestData | null,\n    options?: HttpsCallableStreamOptions\n  ) => {\n    return stream(functionsInstance, name, data, options);\n  };\n\n  return callable as HttpsCallable<RequestData, ResponseData, StreamData>;\n}\n\n/**\n * Returns a reference to the callable https trigger with the given url.\n * @param url - The url of the trigger.\n * @public\n */\nexport function httpsCallableFromURL<\n  RequestData,\n  ResponseData,\n  StreamData = unknown\n>(\n  functionsInstance: FunctionsService,\n  url: string,\n  options?: HttpsCallableOptions\n): HttpsCallable<RequestData, ResponseData, StreamData> {\n  const callable = (\n    data?: RequestData | null\n  ): Promise<HttpsCallableResult> => {\n    return callAtURL(functionsInstance, url, data, options || {});\n  };\n\n  callable.stream = (\n    data?: RequestData | null,\n    options?: HttpsCallableStreamOptions\n  ) => {\n    return streamAtURL(functionsInstance, url, data, options || {});\n  };\n  return callable as HttpsCallable<RequestData, ResponseData, StreamData>;\n}\n\nfunction getCredentials(\n  functionsInstance: FunctionsService\n): 'include' | undefined {\n  return functionsInstance.emulatorOrigin &&\n    isCloudWorkstation(functionsInstance.emulatorOrigin)\n    ? 'include'\n    : undefined;\n}\n\n/**\n * Does an HTTP POST and returns the completed response.\n * @param url The url to post to.\n * @param body The JSON body of the post.\n * @param headers The HTTP headers to include in the request.\n * @param functionsInstance functions instance that is calling postJSON\n * @return A Promise that will succeed when the request finishes.\n */\nasync function postJSON(\n  url: string,\n  body: unknown,\n  headers: { [key: string]: string },\n  fetchImpl: typeof fetch,\n  functionsInstance: FunctionsService\n): Promise<HttpResponse> {\n  headers['Content-Type'] = 'application/json';\n\n  let response: Response;\n  try {\n    response = await fetchImpl(url, {\n      method: 'POST',\n      body: JSON.stringify(body),\n      headers,\n      credentials: getCredentials(functionsInstance)\n    });\n  } catch (e) {\n    // This could be an unhandled error on the backend, or it could be a\n    // network error. There's no way to know, since an unhandled error on the\n    // backend will fail to set the proper CORS header, and thus will be\n    // treated as a network error by fetch.\n    return {\n      status: 0,\n      json: null\n    };\n  }\n  let json: HttpResponseBody | null = null;\n  try {\n    json = await response.json();\n  } catch (e) {\n    // If we fail to parse JSON, it will fail the same as an empty body.\n  }\n  return {\n    status: response.status,\n    json\n  };\n}\n\n/**\n * Creates authorization headers for Firebase Functions requests.\n * @param functionsInstance The Firebase Functions service instance.\n * @param options Options for the callable function, including AppCheck token settings.\n * @return A Promise that resolves a headers map to include in outgoing fetch request.\n */\nasync function makeAuthHeaders(\n  functionsInstance: FunctionsService,\n  options: HttpsCallableOptions\n): Promise<Record<string, string>> {\n  const headers: Record<string, string> = {};\n  const context = await functionsInstance.contextProvider.getContext(\n    options.limitedUseAppCheckTokens\n  );\n  if (context.authToken) {\n    headers['Authorization'] = 'Bearer ' + context.authToken;\n  }\n  if (context.messagingToken) {\n    headers['Firebase-Instance-ID-Token'] = context.messagingToken;\n  }\n  if (context.appCheckToken !== null) {\n    headers['X-Firebase-AppCheck'] = context.appCheckToken;\n  }\n  return headers;\n}\n\n/**\n * Calls a callable function asynchronously and returns the result.\n * @param name The name of the callable trigger.\n * @param data The data to pass as params to the function.\n */\nfunction call(\n  functionsInstance: FunctionsService,\n  name: string,\n  data: unknown,\n  options: HttpsCallableOptions\n): Promise<HttpsCallableResult> {\n  const url = functionsInstance._url(name);\n  return callAtURL(functionsInstance, url, data, options);\n}\n\n/**\n * Calls a callable function asynchronously and returns the result.\n * @param url The url of the callable trigger.\n * @param data The data to pass as params to the function.\n */\nasync function callAtURL(\n  functionsInstance: FunctionsService,\n  url: string,\n  data: unknown,\n  options: HttpsCallableOptions\n): Promise<HttpsCallableResult> {\n  // Encode any special types, such as dates, in the input data.\n  data = encode(data);\n  const body = { data };\n\n  // Add a header for the authToken.\n  const headers = await makeAuthHeaders(functionsInstance, options);\n\n  // Default timeout to 70s, but let the options override it.\n  const timeout = options.timeout || 70000;\n\n  const failAfterHandle = failAfter(timeout);\n  const response = await Promise.race([\n    postJSON(\n      url,\n      body,\n      headers,\n      functionsInstance.fetchImpl,\n      functionsInstance\n    ),\n    failAfterHandle.promise,\n    functionsInstance.cancelAllRequests\n  ]);\n\n  // Always clear the failAfter timeout\n  failAfterHandle.cancel();\n\n  // If service was deleted, interrupted response throws an error.\n  if (!response) {\n    throw new FunctionsError(\n      'cancelled',\n      'Firebase Functions instance was deleted.'\n    );\n  }\n\n  // Check for an error status, regardless of http status.\n  const error = _errorForResponse(response.status, response.json);\n  if (error) {\n    throw error;\n  }\n\n  if (!response.json) {\n    throw new FunctionsError('internal', 'Response is not valid JSON object.');\n  }\n\n  let responseData = response.json.data;\n  // TODO(klimt): For right now, allow \"result\" instead of \"data\", for\n  // backwards compatibility.\n  if (typeof responseData === 'undefined') {\n    responseData = response.json.result;\n  }\n  if (typeof responseData === 'undefined') {\n    // Consider the response malformed.\n    throw new FunctionsError('internal', 'Response is missing data field.');\n  }\n\n  // Decode any special types, such as dates, in the returned data.\n  const decodedData = decode(responseData);\n\n  return { data: decodedData };\n}\n\n/**\n * Calls a callable function asynchronously and returns a streaming result.\n * @param name The name of the callable trigger.\n * @param data The data to pass as params to the function.\n * @param options Streaming request options.\n */\nfunction stream(\n  functionsInstance: FunctionsService,\n  name: string,\n  data: unknown,\n  options?: HttpsCallableStreamOptions\n): Promise<HttpsCallableStreamResult> {\n  const url = functionsInstance._url(name);\n  return streamAtURL(functionsInstance, url, data, options || {});\n}\n\n/**\n * Calls a callable function asynchronously and return a streaming result.\n * @param url The url of the callable trigger.\n * @param data The data to pass as params to the function.\n * @param options Streaming request options.\n */\nasync function streamAtURL(\n  functionsInstance: FunctionsService,\n  url: string,\n  data: unknown,\n  options: HttpsCallableStreamOptions\n): Promise<HttpsCallableStreamResult> {\n  // Encode any special types, such as dates, in the input data.\n  data = encode(data);\n  const body = { data };\n  //\n  // Add a header for the authToken.\n  const headers = await makeAuthHeaders(functionsInstance, options);\n  headers['Content-Type'] = 'application/json';\n  headers['Accept'] = 'text/event-stream';\n\n  let response: Response;\n  try {\n    response = await functionsInstance.fetchImpl(url, {\n      method: 'POST',\n      body: JSON.stringify(body),\n      headers,\n      signal: options?.signal,\n      credentials: getCredentials(functionsInstance)\n    });\n  } catch (e) {\n    if (e instanceof Error && e.name === 'AbortError') {\n      const error = new FunctionsError('cancelled', 'Request was cancelled.');\n      return {\n        data: Promise.reject(error),\n        stream: {\n          [Symbol.asyncIterator]() {\n            return {\n              next() {\n                return Promise.reject(error);\n              }\n            };\n          }\n        }\n      };\n    }\n    // This could be an unhandled error on the backend, or it could be a\n    // network error. There's no way to know, since an unhandled error on the\n    // backend will fail to set the proper CORS header, and thus will be\n    // treated as a network error by fetch.\n    const error = _errorForResponse(0, null);\n    return {\n      data: Promise.reject(error),\n      // Return an empty async iterator\n      stream: {\n        [Symbol.asyncIterator]() {\n          return {\n            next() {\n              return Promise.reject(error);\n            }\n          };\n        }\n      }\n    };\n  }\n  let resultResolver: (value: unknown) => void;\n  let resultRejecter: (reason: unknown) => void;\n  const resultPromise = new Promise<unknown>((resolve, reject) => {\n    resultResolver = resolve;\n    resultRejecter = reject;\n  });\n  options?.signal?.addEventListener('abort', () => {\n    const error = new FunctionsError('cancelled', 'Request was cancelled.');\n    resultRejecter(error);\n  });\n  const reader = response.body!.getReader();\n  const rstream = createResponseStream(\n    reader,\n    resultResolver!,\n    resultRejecter!,\n    options?.signal\n  );\n  return {\n    stream: {\n      [Symbol.asyncIterator]() {\n        const rreader = rstream.getReader();\n        return {\n          async next() {\n            const { value, done } = await rreader.read();\n            return { value: value as unknown, done };\n          },\n          async return() {\n            await rreader.cancel();\n            return { done: true, value: undefined };\n          }\n        };\n      }\n    },\n    data: resultPromise\n  };\n}\n\n/**\n * Creates a ReadableStream that processes a streaming response from a streaming\n * callable function that returns data in server-sent event format.\n *\n * @param reader The underlying reader providing raw response data\n * @param resultResolver Callback to resolve the final result when received\n * @param resultRejecter Callback to reject with an error if encountered\n * @param signal Optional AbortSignal to cancel the stream processing\n * @returns A ReadableStream that emits decoded messages from the response\n *\n * The returned ReadableStream:\n *   1. Emits individual messages when \"message\" data is received\n *   2. Resolves with the final result when a \"result\" message is received\n *   3. Rejects with an error if an \"error\" message is received\n */\nfunction createResponseStream(\n  reader: ReadableStreamDefaultReader<Uint8Array>,\n  resultResolver: (value: unknown) => void,\n  resultRejecter: (reason: unknown) => void,\n  signal?: AbortSignal\n): ReadableStream<unknown> {\n  const processLine = (\n    line: string,\n    controller: ReadableStreamDefaultController\n  ): void => {\n    const match = line.match(responseLineRE);\n    // ignore all other lines (newline, comments, etc.)\n    if (!match) {\n      return;\n    }\n    const data = match[1];\n    try {\n      const jsonData = JSON.parse(data);\n      if ('result' in jsonData) {\n        resultResolver(decode(jsonData.result));\n        return;\n      }\n      if ('message' in jsonData) {\n        controller.enqueue(decode(jsonData.message));\n        return;\n      }\n      if ('error' in jsonData) {\n        const error = _errorForResponse(0, jsonData);\n        controller.error(error);\n        resultRejecter(error);\n        return;\n      }\n    } catch (error) {\n      if (error instanceof FunctionsError) {\n        controller.error(error);\n        resultRejecter(error);\n        return;\n      }\n      // ignore other parsing errors\n    }\n  };\n\n  const decoder = new TextDecoder();\n  return new ReadableStream({\n    start(controller) {\n      let currentText = '';\n      return pump();\n      async function pump(): Promise<void> {\n        if (signal?.aborted) {\n          const error = new FunctionsError(\n            'cancelled',\n            'Request was cancelled'\n          );\n          controller.error(error);\n          resultRejecter(error);\n          return Promise.resolve();\n        }\n        try {\n          const { value, done } = await reader.read();\n          if (done) {\n            if (currentText.trim()) {\n              processLine(currentText.trim(), controller);\n            }\n            controller.close();\n            return;\n          }\n          if (signal?.aborted) {\n            const error = new FunctionsError(\n              'cancelled',\n              'Request was cancelled'\n            );\n            controller.error(error);\n            resultRejecter(error);\n            await reader.cancel();\n            return;\n          }\n          currentText += decoder.decode(value, { stream: true });\n          const lines = currentText.split('\\n');\n          currentText = lines.pop() || '';\n          for (const line of lines) {\n            if (line.trim()) {\n              processLine(line.trim(), controller);\n            }\n          }\n          return pump();\n        } catch (error) {\n          const functionsError =\n            error instanceof FunctionsError\n              ? error\n              : _errorForResponse(0, null);\n          controller.error(functionsError);\n          resultRejecter(functionsError);\n        }\n      }\n    },\n    cancel() {\n      return reader.cancel();\n    }\n  });\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _registerComponent, registerVersion } from '@firebase/app';\nimport { FunctionsService } from './service';\nimport {\n  Component,\n  ComponentType,\n  ComponentContainer,\n  InstanceFactory\n} from '@firebase/component';\nimport { FUNCTIONS_TYPE } from './constants';\nimport { FirebaseAuthInternalName } from '@firebase/auth-interop-types';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\nimport { MessagingInternalComponentName } from '@firebase/messaging-interop-types';\nimport { name, version } from '../package.json';\n\nconst AUTH_INTERNAL_NAME: FirebaseAuthInternalName = 'auth-internal';\nconst APP_CHECK_INTERNAL_NAME: AppCheckInternalComponentName =\n  'app-check-internal';\nconst MESSAGING_INTERNAL_NAME: MessagingInternalComponentName =\n  'messaging-internal';\n\nexport function registerFunctions(variant?: string): void {\n  const factory: InstanceFactory<'functions'> = (\n    container: ComponentContainer,\n    { instanceIdentifier: regionOrCustomDomain }\n  ) => {\n    // Dependencies\n    const app = container.getProvider('app').getImmediate();\n    const authProvider = container.getProvider(AUTH_INTERNAL_NAME);\n    const messagingProvider = container.getProvider(MESSAGING_INTERNAL_NAME);\n    const appCheckProvider = container.getProvider(APP_CHECK_INTERNAL_NAME);\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return new FunctionsService(\n      app,\n      authProvider,\n      messagingProvider,\n      appCheckProvider,\n      regionOrCustomDomain\n    );\n  };\n\n  _registerComponent(\n    new Component(\n      FUNCTIONS_TYPE,\n      factory,\n      ComponentType.PUBLIC\n    ).setMultipleInstances(true)\n  );\n\n  registerVersion(name, version, variant);\n  // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _getProvider, FirebaseApp, getApp } from '@firebase/app';\nimport { FUNCTIONS_TYPE } from './constants';\n\nimport { Provider } from '@firebase/component';\nimport { Functions, HttpsCallableOptions, HttpsCallable } from './public-types';\nimport {\n  FunctionsService,\n  DEFAULT_REGION,\n  connectFunctionsEmulator as _connectFunctionsEmulator,\n  httpsCallable as _httpsCallable,\n  httpsCallableFromURL as _httpsCallableFromURL\n} from './service';\nimport {\n  getModularInstance,\n  getDefaultEmulatorHostnameAndPort\n} from '@firebase/util';\n\nexport { FunctionsError } from './error';\nexport * from './public-types';\n\n/**\n * Returns a {@link Functions} instance for the given app.\n * @param app - The {@link @firebase/app#FirebaseApp} to use.\n * @param regionOrCustomDomain - one of:\n *   a) The region the callable functions are located in (ex: us-central1)\n *   b) A custom domain hosting the callable functions (ex: https://mydomain.com)\n * @public\n */\nexport function getFunctions(\n  app: FirebaseApp = getApp(),\n  regionOrCustomDomain: string = DEFAULT_REGION\n): Functions {\n  // Dependencies\n  const functionsProvider: Provider<'functions'> = _getProvider(\n    getModularInstance(app),\n    FUNCTIONS_TYPE\n  );\n  const functionsInstance = functionsProvider.getImmediate({\n    identifier: regionOrCustomDomain\n  });\n  const emulator = getDefaultEmulatorHostnameAndPort('functions');\n  if (emulator) {\n    connectFunctionsEmulator(functionsInstance, ...emulator);\n  }\n  return functionsInstance;\n}\n\n/**\n * Modify this instance to communicate with the Cloud Functions emulator.\n *\n * Note: this must be called before this instance has been used to do any operations.\n *\n * @param host - The emulator host (ex: localhost)\n * @param port - The emulator port (ex: 5001)\n * @public\n */\nexport function connectFunctionsEmulator(\n  functionsInstance: Functions,\n  host: string,\n  port: number\n): void {\n  _connectFunctionsEmulator(\n    getModularInstance<FunctionsService>(functionsInstance as FunctionsService),\n    host,\n    port\n  );\n}\n\n/**\n * Returns a reference to the callable HTTPS trigger with the given name.\n * @param name - The name of the trigger.\n * @public\n */\nexport function httpsCallable<\n  RequestData = unknown,\n  ResponseData = unknown,\n  StreamData = unknown\n>(\n  functionsInstance: Functions,\n  name: string,\n  options?: HttpsCallableOptions\n): HttpsCallable<RequestData, ResponseData, StreamData> {\n  return _httpsCallable<RequestData, ResponseData, StreamData>(\n    getModularInstance<FunctionsService>(functionsInstance as FunctionsService),\n    name,\n    options\n  );\n}\n\n/**\n * Returns a reference to the callable HTTPS trigger with the specified url.\n * @param url - The url of the trigger.\n * @public\n */\nexport function httpsCallableFromURL<\n  RequestData = unknown,\n  ResponseData = unknown,\n  StreamData = unknown\n>(\n  functionsInstance: Functions,\n  url: string,\n  options?: HttpsCallableOptions\n): HttpsCallable<RequestData, ResponseData, StreamData> {\n  return _httpsCallableFromURL<RequestData, ResponseData, StreamData>(\n    getModularInstance<FunctionsService>(functionsInstance as FunctionsService),\n    url,\n    options\n  );\n}\n", "/**\n * Cloud Functions for Firebase\n *\n * @packageDocumentation\n */\n\n/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { registerFunctions } from './config';\n\nexport * from './api';\nexport * from './public-types';\n\nregisterFunctions();\n", "export * from '@firebase/functions';\n//# sourceMappingURL=index.mjs.map\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Constants used in the Firebase Storage library.\n */\n\n/**\n * Domain name for firebase storage.\n */\nexport const DEFAULT_HOST = 'firebasestorage.googleapis.com';\n\n/**\n * The key in Firebase config json for the storage bucket.\n */\nexport const CONFIG_STORAGE_BUCKET_KEY = 'storageBucket';\n\n/**\n * 2 minutes\n *\n * The timeout for all operations except upload.\n */\nexport const DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1000;\n\n/**\n * 10 minutes\n *\n * The timeout for upload.\n */\nexport const DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1000;\n\n/**\n * 1 second\n */\nexport const DEFAULT_MIN_SLEEP_TIME_MILLIS = 1000;\n\n/**\n * This is the value of Number.MIN_SAFE_INTEGER, which is not well supported\n * enough for us to use it directly.\n */\nexport const MIN_SAFE_INTEGER = -9007199254740991;\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\n\nimport { CONFIG_STORAGE_BUCKET_KEY } from './constants';\n\n/**\n * An error returned by the Firebase Storage SDK.\n * @public\n */\nexport class StorageError extends FirebaseError {\n  private readonly _baseMessage: string;\n  /**\n   * Stores custom error data unique to the `StorageError`.\n   */\n  customData: { serverResponse: string | null } = { serverResponse: null };\n\n  /**\n   * @param code - A `StorageErrorCode` string to be prefixed with 'storage/' and\n   *  added to the end of the message.\n   * @param message  - Error message.\n   * @param status_ - Corresponding HTTP Status Code\n   */\n  constructor(code: StorageErrorCode, message: string, private status_ = 0) {\n    super(\n      prependCode(code),\n      `Firebase Storage: ${message} (${prependCode(code)})`\n    );\n    this._baseMessage = this.message;\n    // Without this, `instanceof StorageError`, in tests for example,\n    // returns false.\n    Object.setPrototypeOf(this, StorageError.prototype);\n  }\n\n  get status(): number {\n    return this.status_;\n  }\n\n  set status(status: number) {\n    this.status_ = status;\n  }\n\n  /**\n   * Compares a `StorageErrorCode` against this error's code, filtering out the prefix.\n   */\n  _codeEquals(code: StorageErrorCode): boolean {\n    return prependCode(code) === this.code;\n  }\n\n  /**\n   * Optional response message that was added by the server.\n   */\n  get serverResponse(): null | string {\n    return this.customData.serverResponse;\n  }\n\n  set serverResponse(serverResponse: string | null) {\n    this.customData.serverResponse = serverResponse;\n    if (this.customData.serverResponse) {\n      this.message = `${this._baseMessage}\\n${this.customData.serverResponse}`;\n    } else {\n      this.message = this._baseMessage;\n    }\n  }\n}\n\nexport const errors = {};\n\n/**\n * @public\n * Error codes that can be attached to `StorageError` objects.\n */\nexport enum StorageErrorCode {\n  // Shared between all platforms\n  UNKNOWN = 'unknown',\n  OBJECT_NOT_FOUND = 'object-not-found',\n  BUCKET_NOT_FOUND = 'bucket-not-found',\n  PROJECT_NOT_FOUND = 'project-not-found',\n  QUOTA_EXCEEDED = 'quota-exceeded',\n  UNAUTHENTICATED = 'unauthenticated',\n  UNAUTHORIZED = 'unauthorized',\n  UNAUTHORIZED_APP = 'unauthorized-app',\n  RETRY_LIMIT_EXCEEDED = 'retry-limit-exceeded',\n  INVALID_CHECKSUM = 'invalid-checksum',\n  CANCELED = 'canceled',\n  // JS specific\n  INVALID_EVENT_NAME = 'invalid-event-name',\n  INVALID_URL = 'invalid-url',\n  INVALID_DEFAULT_BUCKET = 'invalid-default-bucket',\n  NO_DEFAULT_BUCKET = 'no-default-bucket',\n  CANNOT_SLICE_BLOB = 'cannot-slice-blob',\n  SERVER_FILE_WRONG_SIZE = 'server-file-wrong-size',\n  NO_DOWNLOAD_URL = 'no-download-url',\n  INVALID_ARGUMENT = 'invalid-argument',\n  INVALID_ARGUMENT_COUNT = 'invalid-argument-count',\n  APP_DELETED = 'app-deleted',\n  INVALID_ROOT_OPERATION = 'invalid-root-operation',\n  INVALID_FORMAT = 'invalid-format',\n  INTERNAL_ERROR = 'internal-error',\n  UNSUPPORTED_ENVIRONMENT = 'unsupported-environment'\n}\n\nexport function prependCode(code: StorageErrorCode): string {\n  return 'storage/' + code;\n}\n\nexport function unknown(): StorageError {\n  const message =\n    'An unknown error occurred, please check the error payload for ' +\n    'server response.';\n  return new StorageError(StorageErrorCode.UNKNOWN, message);\n}\n\nexport function objectNotFound(path: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.OBJECT_NOT_FOUND,\n    \"Object '\" + path + \"' does not exist.\"\n  );\n}\n\nexport function bucketNotFound(bucket: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.BUCKET_NOT_FOUND,\n    \"Bucket '\" + bucket + \"' does not exist.\"\n  );\n}\n\nexport function projectNotFound(project: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.PROJECT_NOT_FOUND,\n    \"Project '\" + project + \"' does not exist.\"\n  );\n}\n\nexport function quotaExceeded(bucket: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.QUOTA_EXCEEDED,\n    \"Quota for bucket '\" +\n      bucket +\n      \"' exceeded, please view quota on \" +\n      'https://firebase.google.com/pricing/.'\n  );\n}\n\nexport function unauthenticated(): StorageError {\n  const message =\n    'User is not authenticated, please authenticate using Firebase ' +\n    'Authentication and try again.';\n  return new StorageError(StorageErrorCode.UNAUTHENTICATED, message);\n}\n\nexport function unauthorizedApp(): StorageError {\n  return new StorageError(\n    StorageErrorCode.UNAUTHORIZED_APP,\n    'This app does not have permission to access Firebase Storage on this project.'\n  );\n}\n\nexport function unauthorized(path: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.UNAUTHORIZED,\n    \"User does not have permission to access '\" + path + \"'.\"\n  );\n}\n\nexport function retryLimitExceeded(): StorageError {\n  return new StorageError(\n    StorageErrorCode.RETRY_LIMIT_EXCEEDED,\n    'Max retry time for operation exceeded, please try again.'\n  );\n}\n\nexport function invalidChecksum(\n  path: string,\n  checksum: string,\n  calculated: string\n): StorageError {\n  return new StorageError(\n    StorageErrorCode.INVALID_CHECKSUM,\n    \"Uploaded/downloaded object '\" +\n      path +\n      \"' has checksum '\" +\n      checksum +\n      \"' which does not match '\" +\n      calculated +\n      \"'. Please retry the upload/download.\"\n  );\n}\n\nexport function canceled(): StorageError {\n  return new StorageError(\n    StorageErrorCode.CANCELED,\n    'User canceled the upload/download.'\n  );\n}\n\nexport function invalidEventName(name: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.INVALID_EVENT_NAME,\n    \"Invalid event name '\" + name + \"'.\"\n  );\n}\n\nexport function invalidUrl(url: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.INVALID_URL,\n    \"Invalid URL '\" + url + \"'.\"\n  );\n}\n\nexport function invalidDefaultBucket(bucket: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.INVALID_DEFAULT_BUCKET,\n    \"Invalid default bucket '\" + bucket + \"'.\"\n  );\n}\n\nexport function noDefaultBucket(): StorageError {\n  return new StorageError(\n    StorageErrorCode.NO_DEFAULT_BUCKET,\n    'No default bucket ' +\n      \"found. Did you set the '\" +\n      CONFIG_STORAGE_BUCKET_KEY +\n      \"' property when initializing the app?\"\n  );\n}\n\nexport function cannotSliceBlob(): StorageError {\n  return new StorageError(\n    StorageErrorCode.CANNOT_SLICE_BLOB,\n    'Cannot slice blob for upload. Please retry the upload.'\n  );\n}\n\nexport function serverFileWrongSize(): StorageError {\n  return new StorageError(\n    StorageErrorCode.SERVER_FILE_WRONG_SIZE,\n    'Server recorded incorrect upload file size, please retry the upload.'\n  );\n}\n\nexport function noDownloadURL(): StorageError {\n  return new StorageError(\n    StorageErrorCode.NO_DOWNLOAD_URL,\n    'The given file does not have any download URLs.'\n  );\n}\n\nexport function missingPolyFill(polyFill: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.UNSUPPORTED_ENVIRONMENT,\n    `${polyFill} is missing. Make sure to install the required polyfills. See https://firebase.google.com/docs/web/environments-js-sdk#polyfills for more information.`\n  );\n}\n\n/**\n * @internal\n */\nexport function invalidArgument(message: string): StorageError {\n  return new StorageError(StorageErrorCode.INVALID_ARGUMENT, message);\n}\n\nexport function invalidArgumentCount(\n  argMin: number,\n  argMax: number,\n  fnName: string,\n  real: number\n): StorageError {\n  let countPart;\n  let plural;\n  if (argMin === argMax) {\n    countPart = argMin;\n    plural = argMin === 1 ? 'argument' : 'arguments';\n  } else {\n    countPart = 'between ' + argMin + ' and ' + argMax;\n    plural = 'arguments';\n  }\n  return new StorageError(\n    StorageErrorCode.INVALID_ARGUMENT_COUNT,\n    'Invalid argument count in `' +\n      fnName +\n      '`: Expected ' +\n      countPart +\n      ' ' +\n      plural +\n      ', received ' +\n      real +\n      '.'\n  );\n}\n\nexport function appDeleted(): StorageError {\n  return new StorageError(\n    StorageErrorCode.APP_DELETED,\n    'The Firebase app was deleted.'\n  );\n}\n\n/**\n * @param name - The name of the operation that was invalid.\n *\n * @internal\n */\nexport function invalidRootOperation(name: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.INVALID_ROOT_OPERATION,\n    \"The operation '\" +\n      name +\n      \"' cannot be performed on a root reference, create a non-root \" +\n      \"reference using child, such as .child('file.png').\"\n  );\n}\n\n/**\n * @param format - The format that was not valid.\n * @param message - A message describing the format violation.\n */\nexport function invalidFormat(format: string, message: string): StorageError {\n  return new StorageError(\n    StorageErrorCode.INVALID_FORMAT,\n    \"String does not match format '\" + format + \"': \" + message\n  );\n}\n\n/**\n * @param message - A message describing the internal error.\n */\nexport function unsupportedEnvironment(message: string): StorageError {\n  throw new StorageError(StorageErrorCode.UNSUPPORTED_ENVIRONMENT, message);\n}\n\n/**\n * @param message - A message describing the internal error.\n */\nexport function internalError(message: string): StorageError {\n  throw new StorageError(\n    StorageErrorCode.INTERNAL_ERROR,\n    'Internal error: ' + message\n  );\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Functionality related to the parsing/composition of bucket/\n * object location.\n */\n\nimport { invalidDefaultBucket, invalidUrl } from './error';\nimport { DEFAULT_HOST } from './constants';\n\n/**\n * Firebase Storage location data.\n *\n * @internal\n */\nexport class Location {\n  private path_: string;\n\n  constructor(public readonly bucket: string, path: string) {\n    this.path_ = path;\n  }\n\n  get path(): string {\n    return this.path_;\n  }\n\n  get isRoot(): boolean {\n    return this.path.length === 0;\n  }\n\n  fullServerUrl(): string {\n    const encode = encodeURIComponent;\n    return '/b/' + encode(this.bucket) + '/o/' + encode(this.path);\n  }\n\n  bucketOnlyServerUrl(): string {\n    const encode = encodeURIComponent;\n    return '/b/' + encode(this.bucket) + '/o';\n  }\n\n  static makeFromBucketSpec(bucketString: string, host: string): Location {\n    let bucketLocation;\n    try {\n      bucketLocation = Location.makeFromUrl(bucketString, host);\n    } catch (e) {\n      // Not valid URL, use as-is. This lets you put bare bucket names in\n      // config.\n      return new Location(bucketString, '');\n    }\n    if (bucketLocation.path === '') {\n      return bucketLocation;\n    } else {\n      throw invalidDefaultBucket(bucketString);\n    }\n  }\n\n  static makeFromUrl(url: string, host: string): Location {\n    let location: Location | null = null;\n    const bucketDomain = '([A-Za-z0-9.\\\\-_]+)';\n\n    function gsModify(loc: Location): void {\n      if (loc.path.charAt(loc.path.length - 1) === '/') {\n        loc.path_ = loc.path_.slice(0, -1);\n      }\n    }\n    const gsPath = '(/(.*))?$';\n    const gsRegex = new RegExp('^gs://' + bucketDomain + gsPath, 'i');\n    const gsIndices = { bucket: 1, path: 3 };\n\n    function httpModify(loc: Location): void {\n      loc.path_ = decodeURIComponent(loc.path);\n    }\n    const version = 'v[A-Za-z0-9_]+';\n    const firebaseStorageHost = host.replace(/[.]/g, '\\\\.');\n    const firebaseStoragePath = '(/([^?#]*).*)?$';\n    const firebaseStorageRegExp = new RegExp(\n      `^https?://${firebaseStorageHost}/${version}/b/${bucketDomain}/o${firebaseStoragePath}`,\n      'i'\n    );\n    const firebaseStorageIndices = { bucket: 1, path: 3 };\n\n    const cloudStorageHost =\n      host === DEFAULT_HOST\n        ? '(?:storage.googleapis.com|storage.cloud.google.com)'\n        : host;\n    const cloudStoragePath = '([^?#]*)';\n    const cloudStorageRegExp = new RegExp(\n      `^https?://${cloudStorageHost}/${bucketDomain}/${cloudStoragePath}`,\n      'i'\n    );\n    const cloudStorageIndices = { bucket: 1, path: 2 };\n\n    const groups = [\n      { regex: gsRegex, indices: gsIndices, postModify: gsModify },\n      {\n        regex: firebaseStorageRegExp,\n        indices: firebaseStorageIndices,\n        postModify: httpModify\n      },\n      {\n        regex: cloudStorageRegExp,\n        indices: cloudStorageIndices,\n        postModify: httpModify\n      }\n    ];\n    for (let i = 0; i < groups.length; i++) {\n      const group = groups[i];\n      const captures = group.regex.exec(url);\n      if (captures) {\n        const bucketValue = captures[group.indices.bucket];\n        let pathValue = captures[group.indices.path];\n        if (!pathValue) {\n          pathValue = '';\n        }\n        location = new Location(bucketValue, pathValue);\n        group.postModify(location);\n        break;\n      }\n    }\n    if (location == null) {\n      throw invalidUrl(url);\n    }\n    return location;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { StorageError } from './error';\nimport { Request } from './request';\n\n/**\n * A request whose promise always fails.\n */\nexport class FailRequest<T> implements Request<T> {\n  promise_: Promise<T>;\n\n  constructor(error: StorageError) {\n    this.promise_ = Promise.reject<T>(error);\n  }\n\n  /** @inheritDoc */\n  getPromise(): Promise<T> {\n    return this.promise_;\n  }\n\n  /** @inheritDoc */\n  cancel(_appDelete = false): void {}\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Provides a method for running a function with exponential\n * backoff.\n */\ntype id = (p1: boolean) => void;\n\nexport { id };\n\n/**\n * Accepts a callback for an action to perform (`doRequest`),\n * and then a callback for when the backoff has completed (`backoffCompleteCb`).\n * The callback sent to start requires an argument to call (`onRequestComplete`).\n * When `start` calls `doRequest`, it passes a callback for when the request has\n * completed, `onRequestComplete`. Based on this, the backoff continues, with\n * another call to `doRequest` and the above loop continues until the timeout\n * is hit, or a successful response occurs.\n * @description\n * @param doRequest Callback to perform request\n * @param backoffCompleteCb Callback to call when backoff has been completed\n */\nexport function start(\n  doRequest: (\n    onRequestComplete: (success: boolean) => void,\n    canceled: boolean\n  ) => void,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  backoffCompleteCb: (...args: any[]) => unknown,\n  timeout: number\n): id {\n  // TODO(andysoto): make this code cleaner (probably refactor into an actual\n  // type instead of a bunch of functions with state shared in the closure)\n  let waitSeconds = 1;\n  // Would type this as \"number\" but that doesn't work for Node so ¯\\_(ツ)_/¯\n  // TODO: find a way to exclude Node type definition for storage because storage only works in browser\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let retryTimeoutId: any = null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let globalTimeoutId: any = null;\n  let hitTimeout = false;\n  let cancelState = 0;\n\n  function canceled(): boolean {\n    return cancelState === 2;\n  }\n  let triggeredCallback = false;\n\n  function triggerCallback(...args: any[]): void {\n    if (!triggeredCallback) {\n      triggeredCallback = true;\n      backoffCompleteCb.apply(null, args);\n    }\n  }\n\n  function callWithDelay(millis: number): void {\n    retryTimeoutId = setTimeout(() => {\n      retryTimeoutId = null;\n      doRequest(responseHandler, canceled());\n    }, millis);\n  }\n\n  function clearGlobalTimeout(): void {\n    if (globalTimeoutId) {\n      clearTimeout(globalTimeoutId);\n    }\n  }\n\n  function responseHandler(success: boolean, ...args: any[]): void {\n    if (triggeredCallback) {\n      clearGlobalTimeout();\n      return;\n    }\n    if (success) {\n      clearGlobalTimeout();\n      triggerCallback.call(null, success, ...args);\n      return;\n    }\n    const mustStop = canceled() || hitTimeout;\n    if (mustStop) {\n      clearGlobalTimeout();\n      triggerCallback.call(null, success, ...args);\n      return;\n    }\n    if (waitSeconds < 64) {\n      /* TODO(andysoto): don't back off so quickly if we know we're offline. */\n      waitSeconds *= 2;\n    }\n    let waitMillis;\n    if (cancelState === 1) {\n      cancelState = 2;\n      waitMillis = 0;\n    } else {\n      waitMillis = (waitSeconds + Math.random()) * 1000;\n    }\n    callWithDelay(waitMillis);\n  }\n  let stopped = false;\n\n  function stop(wasTimeout: boolean): void {\n    if (stopped) {\n      return;\n    }\n    stopped = true;\n    clearGlobalTimeout();\n    if (triggeredCallback) {\n      return;\n    }\n    if (retryTimeoutId !== null) {\n      if (!wasTimeout) {\n        cancelState = 2;\n      }\n      clearTimeout(retryTimeoutId);\n      callWithDelay(0);\n    } else {\n      if (!wasTimeout) {\n        cancelState = 1;\n      }\n    }\n  }\n  callWithDelay(0);\n  globalTimeoutId = setTimeout(() => {\n    hitTimeout = true;\n    stop(true);\n  }, timeout);\n  return stop;\n}\n\n/**\n * Stops the retry loop from repeating.\n * If the function is currently \"in between\" retries, it is invoked immediately\n * with the second parameter as \"true\". Otherwise, it will be invoked once more\n * after the current invocation finishes iff the current invocation would have\n * triggered another retry.\n */\nexport function stop(id: id): void {\n  id(false);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { invalidArgument } from './error';\n\nexport function isJustDef<T>(p: T | null | undefined): p is T | null {\n  return p !== void 0;\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isFunction(p: unknown): p is Function {\n  return typeof p === 'function';\n}\n\nexport function isNonArrayObject(p: unknown): boolean {\n  return typeof p === 'object' && !Array.isArray(p);\n}\n\nexport function isString(p: unknown): p is string {\n  return typeof p === 'string' || p instanceof String;\n}\n\nexport function isNativeBlob(p: unknown): p is Blob {\n  return isNativeBlobDefined() && p instanceof Blob;\n}\n\nexport function isNativeBlobDefined(): boolean {\n  return typeof Blob !== 'undefined';\n}\n\nexport function validateNumber(\n  argument: string,\n  minValue: number,\n  maxValue: number,\n  value: number\n): void {\n  if (value < minValue) {\n    throw invalidArgument(\n      `Invalid value for '${argument}'. Expected ${minValue} or greater.`\n    );\n  }\n  if (value > maxValue) {\n    throw invalidArgument(\n      `Invalid value for '${argument}'. Expected ${maxValue} or less.`\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Functions to create and manipulate URLs for the server API.\n */\nimport { UrlParams } from './requestinfo';\n\nexport function makeUrl(\n  urlPart: string,\n  host: string,\n  protocol: string\n): string {\n  let origin = host;\n  if (protocol == null) {\n    origin = `https://${host}`;\n  }\n  return `${protocol}://${origin}/v0${urlPart}`;\n}\n\nexport function makeQueryString(params: UrlParams): string {\n  const encode = encodeURIComponent;\n  let queryPart = '?';\n  for (const key in params) {\n    if (params.hasOwnProperty(key)) {\n      const nextPart = encode(key) + '=' + encode(params[key]);\n      queryPart = queryPart + nextPart + '&';\n    }\n  }\n\n  // Chop off the extra '&' or '?' on the end\n  queryPart = queryPart.slice(0, -1);\n  return queryPart;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/** Network headers */\nexport type Headers = Record<string, string>;\n\n/** Response type exposed by the networking APIs. */\nexport type ConnectionType =\n  | string\n  | ArrayBuffer\n  | Blob\n  | ReadableStream<Uint8Array>;\n\n/**\n * A lightweight wrapper around XMLHttpRequest with a\n * goog.net.XhrIo-like interface.\n *\n * You can create a new connection by invoking `newTextConnection()`,\n * `newBytesConnection()` or `newStreamConnection()`.\n */\nexport interface Connection<T extends ConnectionType> {\n  /**\n   * Sends a request to the provided URL.\n   *\n   * This method never rejects its promise. In case of encountering an error,\n   * it sets an error code internally which can be accessed by calling\n   * getErrorCode() by callers.\n   */\n  send(\n    url: string,\n    method: string,\n    isUsingEmulator: boolean,\n    body?: ArrayBufferView | Blob | string | null,\n    headers?: Headers\n  ): Promise<void>;\n\n  getErrorCode(): ErrorCode;\n\n  getStatus(): number;\n\n  getResponse(): T;\n\n  getErrorText(): string;\n\n  /**\n   * Abort the request.\n   */\n  abort(): void;\n\n  getResponseHeader(header: string): string | null;\n\n  addUploadProgressListener(listener: (p1: ProgressEvent) => void): void;\n\n  removeUploadProgressListener(listener: (p1: ProgressEvent) => void): void;\n}\n\n/**\n * Error codes for requests made by the XhrIo wrapper.\n */\nexport enum ErrorCode {\n  NO_ERROR = 0,\n  NETWORK_ERROR = 1,\n  ABORT = 2\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Checks the status code to see if the action should be retried.\n *\n * @param status Current HTTP status code returned by server.\n * @param additionalRetryCodes additional retry codes to check against\n */\nexport function isRetryStatusCode(\n  status: number,\n  additionalRetryCodes: number[]\n): boolean {\n  // The codes for which to retry came from this page:\n  // https://cloud.google.com/storage/docs/exponential-backoff\n  const isFiveHundredCode = status >= 500 && status < 600;\n  const extraRetryCodes = [\n    // Request Timeout: web server didn't receive full request in time.\n    408,\n    // Too Many Requests: you're getting rate-limited, basically.\n    429\n  ];\n  const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;\n  const isAdditionalRetryCode = additionalRetryCodes.indexOf(status) !== -1;\n  return isFiveHundredCode || isExtraRetryCode || isAdditionalRetryCode;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Defines methods used to actually send HTTP requests from\n * abstract representations.\n */\n\nimport { id as backoffId, start, stop } from './backoff';\nimport { appDeleted, canceled, retryLimitExceeded, unknown } from './error';\nimport { ErrorHandler, RequestHandler, RequestInfo } from './requestinfo';\nimport { isJustDef } from './type';\nimport { makeQueryString } from './url';\nimport { Connection, ErrorCode, Headers, ConnectionType } from './connection';\nimport { isRetryStatusCode } from './utils';\n\nexport interface Request<T> {\n  getPromise(): Promise<T>;\n\n  /**\n   * Cancels the request. IMPORTANT: the promise may still be resolved with an\n   * appropriate value (if the request is finished before you call this method,\n   * but the promise has not yet been resolved), so don't just assume it will be\n   * rejected if you call this function.\n   * @param appDelete - True if the cancelation came from the app being deleted.\n   */\n  cancel(appDelete?: boolean): void;\n}\n\n/**\n * Handles network logic for all Storage Requests, including error reporting and\n * retries with backoff.\n *\n * @param I - the type of the backend's network response.\n * @param - O the output type used by the rest of the SDK. The conversion\n * happens in the specified `callback_`.\n */\nclass NetworkRequest<I extends ConnectionType, O> implements Request<O> {\n  private pendingConnection_: Connection<I> | null = null;\n  private backoffId_: backoffId | null = null;\n  private resolve_!: (value?: O | PromiseLike<O>) => void;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private reject_!: (reason?: any) => void;\n  private canceled_: boolean = false;\n  private appDelete_: boolean = false;\n  private promise_: Promise<O>;\n\n  constructor(\n    private url_: string,\n    private method_: string,\n    private headers_: Headers,\n    private body_: string | Blob | Uint8Array | null,\n    private successCodes_: number[],\n    private additionalRetryCodes_: number[],\n    private callback_: RequestHandler<I, O>,\n    private errorCallback_: ErrorHandler | null,\n    private timeout_: number,\n    private progressCallback_: ((p1: number, p2: number) => void) | null,\n    private connectionFactory_: () => Connection<I>,\n    private retry = true,\n    private isUsingEmulator = false\n  ) {\n    this.promise_ = new Promise((resolve, reject) => {\n      this.resolve_ = resolve as (value?: O | PromiseLike<O>) => void;\n      this.reject_ = reject;\n      this.start_();\n    });\n  }\n\n  /**\n   * Actually starts the retry loop.\n   */\n  private start_(): void {\n    const doTheRequest: (\n      backoffCallback: (success: boolean, ...p2: unknown[]) => void,\n      canceled: boolean\n    ) => void = (backoffCallback, canceled) => {\n      if (canceled) {\n        backoffCallback(false, new RequestEndStatus(false, null, true));\n        return;\n      }\n      const connection = this.connectionFactory_();\n      this.pendingConnection_ = connection;\n\n      const progressListener: (\n        progressEvent: ProgressEvent\n      ) => void = progressEvent => {\n        const loaded = progressEvent.loaded;\n        const total = progressEvent.lengthComputable ? progressEvent.total : -1;\n        if (this.progressCallback_ !== null) {\n          this.progressCallback_(loaded, total);\n        }\n      };\n      if (this.progressCallback_ !== null) {\n        connection.addUploadProgressListener(progressListener);\n      }\n\n      // connection.send() never rejects, so we don't need to have a error handler or use catch on the returned promise.\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      connection\n        .send(\n          this.url_,\n          this.method_,\n          this.isUsingEmulator,\n          this.body_,\n          this.headers_\n        )\n        .then(() => {\n          if (this.progressCallback_ !== null) {\n            connection.removeUploadProgressListener(progressListener);\n          }\n          this.pendingConnection_ = null;\n          const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;\n          const status = connection.getStatus();\n          if (\n            !hitServer ||\n            (isRetryStatusCode(status, this.additionalRetryCodes_) &&\n              this.retry)\n          ) {\n            const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;\n            backoffCallback(\n              false,\n              new RequestEndStatus(false, null, wasCanceled)\n            );\n            return;\n          }\n          const successCode = this.successCodes_.indexOf(status) !== -1;\n          backoffCallback(true, new RequestEndStatus(successCode, connection));\n        });\n    };\n\n    /**\n     * @param requestWentThrough - True if the request eventually went\n     *     through, false if it hit the retry limit or was canceled.\n     */\n    const backoffDone: (\n      requestWentThrough: boolean,\n      status: RequestEndStatus<I>\n    ) => void = (requestWentThrough, status) => {\n      const resolve = this.resolve_;\n      const reject = this.reject_;\n      const connection = status.connection as Connection<I>;\n      if (status.wasSuccessCode) {\n        try {\n          const result = this.callback_(connection, connection.getResponse());\n          if (isJustDef(result)) {\n            resolve(result);\n          } else {\n            resolve();\n          }\n        } catch (e) {\n          reject(e);\n        }\n      } else {\n        if (connection !== null) {\n          const err = unknown();\n          err.serverResponse = connection.getErrorText();\n          if (this.errorCallback_) {\n            reject(this.errorCallback_(connection, err));\n          } else {\n            reject(err);\n          }\n        } else {\n          if (status.canceled) {\n            const err = this.appDelete_ ? appDeleted() : canceled();\n            reject(err);\n          } else {\n            const err = retryLimitExceeded();\n            reject(err);\n          }\n        }\n      }\n    };\n    if (this.canceled_) {\n      backoffDone(false, new RequestEndStatus(false, null, true));\n    } else {\n      this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_);\n    }\n  }\n\n  /** @inheritDoc */\n  getPromise(): Promise<O> {\n    return this.promise_;\n  }\n\n  /** @inheritDoc */\n  cancel(appDelete?: boolean): void {\n    this.canceled_ = true;\n    this.appDelete_ = appDelete || false;\n    if (this.backoffId_ !== null) {\n      stop(this.backoffId_);\n    }\n    if (this.pendingConnection_ !== null) {\n      this.pendingConnection_.abort();\n    }\n  }\n}\n\n/**\n * A collection of information about the result of a network request.\n * @param opt_canceled - Defaults to false.\n */\nexport class RequestEndStatus<I extends ConnectionType> {\n  /**\n   * True if the request was canceled.\n   */\n  canceled: boolean;\n\n  constructor(\n    public wasSuccessCode: boolean,\n    public connection: Connection<I> | null,\n    canceled?: boolean\n  ) {\n    this.canceled = !!canceled;\n  }\n}\n\nexport function addAuthHeader_(\n  headers: Headers,\n  authToken: string | null\n): void {\n  if (authToken !== null && authToken.length > 0) {\n    headers['Authorization'] = 'Firebase ' + authToken;\n  }\n}\n\nexport function addVersionHeader_(\n  headers: Headers,\n  firebaseVersion?: string\n): void {\n  headers['X-Firebase-Storage-Version'] =\n    'webjs/' + (firebaseVersion ?? 'AppManager');\n}\n\nexport function addGmpidHeader_(headers: Headers, appId: string | null): void {\n  if (appId) {\n    headers['X-Firebase-GMPID'] = appId;\n  }\n}\n\nexport function addAppCheckHeader_(\n  headers: Headers,\n  appCheckToken: string | null\n): void {\n  if (appCheckToken !== null) {\n    headers['X-Firebase-AppCheck'] = appCheckToken;\n  }\n}\n\nexport function makeRequest<I extends ConnectionType, O>(\n  requestInfo: RequestInfo<I, O>,\n  appId: string | null,\n  authToken: string | null,\n  appCheckToken: string | null,\n  requestFactory: () => Connection<I>,\n  firebaseVersion?: string,\n  retry = true,\n  isUsingEmulator = false\n): Request<O> {\n  const queryPart = makeQueryString(requestInfo.urlParams);\n  const url = requestInfo.url + queryPart;\n  const headers = Object.assign({}, requestInfo.headers);\n  addGmpidHeader_(headers, appId);\n  addAuthHeader_(headers, authToken);\n  addVersionHeader_(headers, firebaseVersion);\n  addAppCheckHeader_(headers, appCheckToken);\n  return new NetworkRequest<I, O>(\n    url,\n    requestInfo.method,\n    headers,\n    requestInfo.body,\n    requestInfo.successCodes,\n    requestInfo.additionalRetryCodes,\n    requestInfo.handler,\n    requestInfo.errorHandler,\n    requestInfo.timeout,\n    requestInfo.progressCallback,\n    requestFactory,\n    retry,\n    isUsingEmulator\n  );\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Some methods copied from goog.fs.\n * We don't include goog.fs because it pulls in a bunch of Deferred code that\n * bloats the size of the released binary.\n */\nimport { isNativeBlobDefined } from './type';\nimport { StorageErrorCode, StorageError } from './error';\n\nfunction getBlobBuilder(): typeof IBlobBuilder | undefined {\n  if (typeof BlobBuilder !== 'undefined') {\n    return BlobBuilder;\n  } else if (typeof WebKitBlobBuilder !== 'undefined') {\n    return WebKitBlobBuilder;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Concatenates one or more values together and converts them to a Blob.\n *\n * @param args The values that will make up the resulting blob.\n * @return The blob.\n */\nexport function getBlob(...args: Array<string | Blob | ArrayBuffer>): Blob {\n  const BlobBuilder = getBlobBuilder();\n  if (BlobBuilder !== undefined) {\n    const bb = new BlobBuilder();\n    for (let i = 0; i < args.length; i++) {\n      bb.append(args[i]);\n    }\n    return bb.getBlob();\n  } else {\n    if (isNativeBlobDefined()) {\n      return new Blob(args);\n    } else {\n      throw new StorageError(\n        StorageErrorCode.UNSUPPORTED_ENVIRONMENT,\n        \"This browser doesn't seem to support creating Blobs\"\n      );\n    }\n  }\n}\n\n/**\n * Slices the blob. The returned blob contains data from the start byte\n * (inclusive) till the end byte (exclusive). Negative indices cannot be used.\n *\n * @param blob The blob to be sliced.\n * @param start Index of the starting byte.\n * @param end Index of the ending byte.\n * @return The blob slice or null if not supported.\n */\nexport function sliceBlob(blob: Blob, start: number, end: number): Blob | null {\n  if (blob.webkitSlice) {\n    return blob.webkitSlice(start, end);\n  } else if (blob.mozSlice) {\n    return blob.mozSlice(start, end);\n  } else if (blob.slice) {\n    return blob.slice(start, end);\n  }\n  return null;\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TextDecoder } from 'util';\nimport { invalidFormat } from '../../implementation/error';\n\n/** Converts a Base64 encoded string to a binary string. */\nexport function decodeBase64(encoded: string): string {\n  // Node actually doesn't validate base64 strings.\n  // A quick sanity check that is not a fool-proof validation\n  if (/[^-A-Za-z0-9+/=]/.test(encoded)) {\n    throw invalidFormat('base64', 'Invalid character found');\n  }\n  return Buffer.from(encoded, 'base64').toString('binary');\n}\n\nexport function decodeUint8Array(data: Uint8Array): string {\n  return new TextDecoder().decode(data);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { unknown, invalidFormat } from './error';\nimport { decodeBase64 } from '../platform/base64';\n\n/**\n * An enumeration of the possible string formats for upload.\n * @public\n */\nexport type StringFormat = (typeof StringFormat)[keyof typeof StringFormat];\n/**\n * An enumeration of the possible string formats for upload.\n * @public\n */\nexport const StringFormat = {\n  /**\n   * Indicates the string should be interpreted \"raw\", that is, as normal text.\n   * The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte\n   * sequence.\n   * Example: The string 'Hello! \\\\ud83d\\\\ude0a' becomes the byte sequence\n   * 48 65 6c 6c 6f 21 20 f0 9f 98 8a\n   */\n  RAW: 'raw',\n  /**\n   * Indicates the string should be interpreted as base64-encoded data.\n   * Padding characters (trailing '='s) are optional.\n   * Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence\n   * ad 69 8e fb e1 3a b7 bf eb 97\n   */\n  BASE64: 'base64',\n  /**\n   * Indicates the string should be interpreted as base64url-encoded data.\n   * Padding characters (trailing '='s) are optional.\n   * Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence\n   * ad 69 8e fb e1 3a b7 bf eb 97\n   */\n  BASE64URL: 'base64url',\n  /**\n   * Indicates the string is a data URL, such as one obtained from\n   * canvas.toDataURL().\n   * Example: the string 'data:application/octet-stream;base64,aaaa'\n   * becomes the byte sequence\n   * 69 a6 9a\n   * (the content-type \"application/octet-stream\" is also applied, but can\n   * be overridden in the metadata object).\n   */\n  DATA_URL: 'data_url'\n} as const;\n\nexport class StringData {\n  contentType: string | null;\n\n  constructor(public data: Uint8Array, contentType?: string | null) {\n    this.contentType = contentType || null;\n  }\n}\n\n/**\n * @internal\n */\nexport function dataFromString(\n  format: StringFormat,\n  stringData: string\n): StringData {\n  switch (format) {\n    case StringFormat.RAW:\n      return new StringData(utf8Bytes_(stringData));\n    case StringFormat.BASE64:\n    case StringFormat.BASE64URL:\n      return new StringData(base64Bytes_(format, stringData));\n    case StringFormat.DATA_URL:\n      return new StringData(\n        dataURLBytes_(stringData),\n        dataURLContentType_(stringData)\n      );\n    default:\n    // do nothing\n  }\n\n  // assert(false);\n  throw unknown();\n}\n\nexport function utf8Bytes_(value: string): Uint8Array {\n  const b: number[] = [];\n  for (let i = 0; i < value.length; i++) {\n    let c = value.charCodeAt(i);\n    if (c <= 127) {\n      b.push(c);\n    } else {\n      if (c <= 2047) {\n        b.push(192 | (c >> 6), 128 | (c & 63));\n      } else {\n        if ((c & 64512) === 55296) {\n          // The start of a surrogate pair.\n          const valid =\n            i < value.length - 1 && (value.charCodeAt(i + 1) & 64512) === 56320;\n          if (!valid) {\n            // The second surrogate wasn't there.\n            b.push(239, 191, 189);\n          } else {\n            const hi = c;\n            const lo = value.charCodeAt(++i);\n            c = 65536 | ((hi & 1023) << 10) | (lo & 1023);\n            b.push(\n              240 | (c >> 18),\n              128 | ((c >> 12) & 63),\n              128 | ((c >> 6) & 63),\n              128 | (c & 63)\n            );\n          }\n        } else {\n          if ((c & 64512) === 56320) {\n            // Invalid low surrogate.\n            b.push(239, 191, 189);\n          } else {\n            b.push(224 | (c >> 12), 128 | ((c >> 6) & 63), 128 | (c & 63));\n          }\n        }\n      }\n    }\n  }\n  return new Uint8Array(b);\n}\n\nexport function percentEncodedBytes_(value: string): Uint8Array {\n  let decoded;\n  try {\n    decoded = decodeURIComponent(value);\n  } catch (e) {\n    throw invalidFormat(StringFormat.DATA_URL, 'Malformed data URL.');\n  }\n  return utf8Bytes_(decoded);\n}\n\nexport function base64Bytes_(format: StringFormat, value: string): Uint8Array {\n  switch (format) {\n    case StringFormat.BASE64: {\n      const hasMinus = value.indexOf('-') !== -1;\n      const hasUnder = value.indexOf('_') !== -1;\n      if (hasMinus || hasUnder) {\n        const invalidChar = hasMinus ? '-' : '_';\n        throw invalidFormat(\n          format,\n          \"Invalid character '\" +\n            invalidChar +\n            \"' found: is it base64url encoded?\"\n        );\n      }\n      break;\n    }\n    case StringFormat.BASE64URL: {\n      const hasPlus = value.indexOf('+') !== -1;\n      const hasSlash = value.indexOf('/') !== -1;\n      if (hasPlus || hasSlash) {\n        const invalidChar = hasPlus ? '+' : '/';\n        throw invalidFormat(\n          format,\n          \"Invalid character '\" + invalidChar + \"' found: is it base64 encoded?\"\n        );\n      }\n      value = value.replace(/-/g, '+').replace(/_/g, '/');\n      break;\n    }\n    default:\n    // do nothing\n  }\n  let bytes;\n  try {\n    bytes = decodeBase64(value);\n  } catch (e) {\n    if ((e as Error).message.includes('polyfill')) {\n      throw e;\n    }\n    throw invalidFormat(format, 'Invalid character found');\n  }\n  const array = new Uint8Array(bytes.length);\n  for (let i = 0; i < bytes.length; i++) {\n    array[i] = bytes.charCodeAt(i);\n  }\n  return array;\n}\n\nclass DataURLParts {\n  base64: boolean = false;\n  contentType: string | null = null;\n  rest: string;\n\n  constructor(dataURL: string) {\n    const matches = dataURL.match(/^data:([^,]+)?,/);\n    if (matches === null) {\n      throw invalidFormat(\n        StringFormat.DATA_URL,\n        \"Must be formatted 'data:[<mediatype>][;base64],<data>\"\n      );\n    }\n    const middle = matches[1] || null;\n    if (middle != null) {\n      this.base64 = endsWith(middle, ';base64');\n      this.contentType = this.base64\n        ? middle.substring(0, middle.length - ';base64'.length)\n        : middle;\n    }\n    this.rest = dataURL.substring(dataURL.indexOf(',') + 1);\n  }\n}\n\nexport function dataURLBytes_(dataUrl: string): Uint8Array {\n  const parts = new DataURLParts(dataUrl);\n  if (parts.base64) {\n    return base64Bytes_(StringFormat.BASE64, parts.rest);\n  } else {\n    return percentEncodedBytes_(parts.rest);\n  }\n}\n\nexport function dataURLContentType_(dataUrl: string): string | null {\n  const parts = new DataURLParts(dataUrl);\n  return parts.contentType;\n}\n\nfunction endsWith(s: string, end: string): boolean {\n  const longEnough = s.length >= end.length;\n  if (!longEnough) {\n    return false;\n  }\n\n  return s.substring(s.length - end.length) === end;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @file Provides a Blob-like wrapper for various binary types (including the\n * native Blob type). This makes it possible to upload types like ArrayBuffers,\n * making uploads possible in environments without the native Blob type.\n */\nimport { sliceBlob, getBlob } from './fs';\nimport { StringFormat, dataFromString } from './string';\nimport { isNativeBlob, isNativeBlobDefined, isString } from './type';\n\n/**\n * @param opt_elideCopy - If true, doesn't copy mutable input data\n *     (e.g. Uint8Arrays). Pass true only if you know the objects will not be\n *     modified after this blob's construction.\n *\n * @internal\n */\nexport class FbsBlob {\n  private data_!: Blob | Uint8Array;\n  private size_: number;\n  private type_: string;\n\n  constructor(data: Blob | Uint8Array | ArrayBuffer, elideCopy?: boolean) {\n    let size: number = 0;\n    let blobType: string = '';\n    if (isNativeBlob(data)) {\n      this.data_ = data as Blob;\n      size = (data as Blob).size;\n      blobType = (data as Blob).type;\n    } else if (data instanceof ArrayBuffer) {\n      if (elideCopy) {\n        this.data_ = new Uint8Array(data);\n      } else {\n        this.data_ = new Uint8Array(data.byteLength);\n        this.data_.set(new Uint8Array(data));\n      }\n      size = this.data_.length;\n    } else if (data instanceof Uint8Array) {\n      if (elideCopy) {\n        this.data_ = data as Uint8Array;\n      } else {\n        this.data_ = new Uint8Array(data.length);\n        this.data_.set(data as Uint8Array);\n      }\n      size = data.length;\n    }\n    this.size_ = size;\n    this.type_ = blobType;\n  }\n\n  size(): number {\n    return this.size_;\n  }\n\n  type(): string {\n    return this.type_;\n  }\n\n  slice(startByte: number, endByte: number): FbsBlob | null {\n    if (isNativeBlob(this.data_)) {\n      const realBlob = this.data_ as Blob;\n      const sliced = sliceBlob(realBlob, startByte, endByte);\n      if (sliced === null) {\n        return null;\n      }\n      return new FbsBlob(sliced);\n    } else {\n      const slice = new Uint8Array(\n        (this.data_ as Uint8Array).buffer,\n        startByte,\n        endByte - startByte\n      );\n      return new FbsBlob(slice, true);\n    }\n  }\n\n  static getBlob(...args: Array<string | FbsBlob>): FbsBlob | null {\n    if (isNativeBlobDefined()) {\n      const blobby: Array<Blob | Uint8Array | string> = args.map(\n        (val: string | FbsBlob): Blob | Uint8Array | string => {\n          if (val instanceof FbsBlob) {\n            return val.data_;\n          } else {\n            return val;\n          }\n        }\n      );\n      return new FbsBlob(getBlob.apply(null, blobby));\n    } else {\n      const uint8Arrays: Uint8Array[] = args.map(\n        (val: string | FbsBlob): Uint8Array => {\n          if (isString(val)) {\n            return dataFromString(StringFormat.RAW, val as string).data;\n          } else {\n            // Blobs don't exist, so this has to be a Uint8Array.\n            return (val as FbsBlob).data_ as Uint8Array;\n          }\n        }\n      );\n      let finalLength = 0;\n      uint8Arrays.forEach((array: Uint8Array): void => {\n        finalLength += array.byteLength;\n      });\n      const merged = new Uint8Array(finalLength);\n      let index = 0;\n      uint8Arrays.forEach((array: Uint8Array) => {\n        for (let i = 0; i < array.length; i++) {\n          merged[index++] = array[i];\n        }\n      });\n      return new FbsBlob(merged, true);\n    }\n  }\n\n  uploadData(): Blob | Uint8Array {\n    return this.data_;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { isNonArrayObject } from './type';\n\n/**\n * Returns the Object resulting from parsing the given JSON, or null if the\n * given string does not represent a JSON object.\n */\nexport function jsonObjectOrNull(\n  s: string\n): { [name: string]: unknown } | null {\n  let obj;\n  try {\n    obj = JSON.parse(s);\n  } catch (e) {\n    return null;\n  }\n  if (isNonArrayObject(obj)) {\n    return obj;\n  } else {\n    return null;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Contains helper methods for manipulating paths.\n */\n\n/**\n * @return Null if the path is already at the root.\n */\nexport function parent(path: string): string | null {\n  if (path.length === 0) {\n    return null;\n  }\n  const index = path.lastIndexOf('/');\n  if (index === -1) {\n    return '';\n  }\n  const newPath = path.slice(0, index);\n  return newPath;\n}\n\nexport function child(path: string, childPath: string): string {\n  const canonicalChildPath = childPath\n    .split('/')\n    .filter(component => component.length > 0)\n    .join('/');\n  if (path.length === 0) {\n    return canonicalChildPath;\n  } else {\n    return path + '/' + canonicalChildPath;\n  }\n}\n\n/**\n * Returns the last component of a path.\n * '/foo/bar' -> 'bar'\n * '/foo/bar/baz/' -> 'baz/'\n * '/a' -> 'a'\n */\nexport function lastComponent(path: string): string {\n  const index = path.lastIndexOf('/', path.length - 2);\n  if (index === -1) {\n    return path;\n  } else {\n    return path.slice(index + 1);\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Documentation for the metadata format\n */\nimport { Metadata } from '../metadata';\n\nimport { jsonObjectOrNull } from './json';\nimport { Location } from './location';\nimport { lastComponent } from './path';\nimport { isString } from './type';\nimport { makeUrl, makeQueryString } from './url';\nimport { Reference } from '../reference';\nimport { FirebaseStorageImpl } from '../service';\n\nexport function noXform_<T>(metadata: Metadata, value: T): T {\n  return value;\n}\n\nclass Mapping<T> {\n  local: string;\n  writable: boolean;\n  xform: (p1: Metadata, p2?: T) => T | undefined;\n\n  constructor(\n    public server: string,\n    local?: string | null,\n    writable?: boolean,\n    xform?: ((p1: Metadata, p2?: T) => T | undefined) | null\n  ) {\n    this.local = local || server;\n    this.writable = !!writable;\n    this.xform = xform || noXform_;\n  }\n}\ntype Mappings = Array<Mapping<string> | Mapping<number>>;\n\nexport { Mappings };\n\nlet mappings_: Mappings | null = null;\n\nexport function xformPath(fullPath: string | undefined): string | undefined {\n  if (!isString(fullPath) || fullPath.length < 2) {\n    return fullPath;\n  } else {\n    return lastComponent(fullPath);\n  }\n}\n\nexport function getMappings(): Mappings {\n  if (mappings_) {\n    return mappings_;\n  }\n  const mappings: Mappings = [];\n  mappings.push(new Mapping<string>('bucket'));\n  mappings.push(new Mapping<string>('generation'));\n  mappings.push(new Mapping<string>('metageneration'));\n  mappings.push(new Mapping<string>('name', 'fullPath', true));\n\n  function mappingsXformPath(\n    _metadata: Metadata,\n    fullPath: string | undefined\n  ): string | undefined {\n    return xformPath(fullPath);\n  }\n  const nameMapping = new Mapping<string>('name');\n  nameMapping.xform = mappingsXformPath;\n  mappings.push(nameMapping);\n\n  /**\n   * Coerces the second param to a number, if it is defined.\n   */\n  function xformSize(\n    _metadata: Metadata,\n    size?: number | string\n  ): number | undefined {\n    if (size !== undefined) {\n      return Number(size);\n    } else {\n      return size;\n    }\n  }\n  const sizeMapping = new Mapping<number>('size');\n  sizeMapping.xform = xformSize;\n  mappings.push(sizeMapping);\n  mappings.push(new Mapping<number>('timeCreated'));\n  mappings.push(new Mapping<string>('updated'));\n  mappings.push(new Mapping<string>('md5Hash', null, true));\n  mappings.push(new Mapping<string>('cacheControl', null, true));\n  mappings.push(new Mapping<string>('contentDisposition', null, true));\n  mappings.push(new Mapping<string>('contentEncoding', null, true));\n  mappings.push(new Mapping<string>('contentLanguage', null, true));\n  mappings.push(new Mapping<string>('contentType', null, true));\n  mappings.push(new Mapping<string>('metadata', 'customMetadata', true));\n  mappings_ = mappings;\n  return mappings_;\n}\n\nexport function addRef(metadata: Metadata, service: FirebaseStorageImpl): void {\n  function generateRef(): Reference {\n    const bucket: string = metadata['bucket'] as string;\n    const path: string = metadata['fullPath'] as string;\n    const loc = new Location(bucket, path);\n    return service._makeStorageReference(loc);\n  }\n  Object.defineProperty(metadata, 'ref', { get: generateRef });\n}\n\nexport function fromResource(\n  service: FirebaseStorageImpl,\n  resource: { [name: string]: unknown },\n  mappings: Mappings\n): Metadata {\n  const metadata: Metadata = {} as Metadata;\n  metadata['type'] = 'file';\n  const len = mappings.length;\n  for (let i = 0; i < len; i++) {\n    const mapping = mappings[i];\n    metadata[mapping.local] = (mapping as Mapping<unknown>).xform(\n      metadata,\n      resource[mapping.server]\n    );\n  }\n  addRef(metadata, service);\n  return metadata;\n}\n\nexport function fromResourceString(\n  service: FirebaseStorageImpl,\n  resourceString: string,\n  mappings: Mappings\n): Metadata | null {\n  const obj = jsonObjectOrNull(resourceString);\n  if (obj === null) {\n    return null;\n  }\n  const resource = obj as Metadata;\n  return fromResource(service, resource, mappings);\n}\n\nexport function downloadUrlFromResourceString(\n  metadata: Metadata,\n  resourceString: string,\n  host: string,\n  protocol: string\n): string | null {\n  const obj = jsonObjectOrNull(resourceString);\n  if (obj === null) {\n    return null;\n  }\n  if (!isString(obj['downloadTokens'])) {\n    // This can happen if objects are uploaded through GCS and retrieved\n    // through list, so we don't want to throw an Error.\n    return null;\n  }\n  const tokens: string = obj['downloadTokens'] as string;\n  if (tokens.length === 0) {\n    return null;\n  }\n  const encode = encodeURIComponent;\n  const tokensList = tokens.split(',');\n  const urls = tokensList.map((token: string): string => {\n    const bucket: string = metadata['bucket'] as string;\n    const path: string = metadata['fullPath'] as string;\n    const urlPart = '/b/' + encode(bucket) + '/o/' + encode(path);\n    const base = makeUrl(urlPart, host, protocol);\n    const queryString = makeQueryString({\n      alt: 'media',\n      token\n    });\n    return base + queryString;\n  });\n  return urls[0];\n}\n\nexport function toResourceString(\n  metadata: Partial<Metadata>,\n  mappings: Mappings\n): string {\n  const resource: {\n    [prop: string]: unknown;\n  } = {};\n  const len = mappings.length;\n  for (let i = 0; i < len; i++) {\n    const mapping = mappings[i];\n    if (mapping.writable) {\n      resource[mapping.server] = metadata[mapping.local];\n    }\n  }\n  return JSON.stringify(resource);\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Documentation for the listOptions and listResult format\n */\nimport { Location } from './location';\nimport { jsonObjectOrNull } from './json';\nimport { ListResult } from '../list';\nimport { FirebaseStorageImpl } from '../service';\n\n/**\n * Represents the simplified object metadata returned by List API.\n * Other fields are filtered because list in Firebase Rules does not grant\n * the permission to read the metadata.\n */\ninterface ListMetadataResponse {\n  name: string;\n  bucket: string;\n}\n\n/**\n * Represents the JSON response of List API.\n */\ninterface ListResultResponse {\n  prefixes: string[];\n  items: ListMetadataResponse[];\n  nextPageToken?: string;\n}\n\nconst PREFIXES_KEY = 'prefixes';\nconst ITEMS_KEY = 'items';\n\nfunction fromBackendResponse(\n  service: FirebaseStorageImpl,\n  bucket: string,\n  resource: ListResultResponse\n): ListResult {\n  const listResult: ListResult = {\n    prefixes: [],\n    items: [],\n    nextPageToken: resource['nextPageToken']\n  };\n  if (resource[PREFIXES_KEY]) {\n    for (const path of resource[PREFIXES_KEY]) {\n      const pathWithoutTrailingSlash = path.replace(/\\/$/, '');\n      const reference = service._makeStorageReference(\n        new Location(bucket, pathWithoutTrailingSlash)\n      );\n      listResult.prefixes.push(reference);\n    }\n  }\n\n  if (resource[ITEMS_KEY]) {\n    for (const item of resource[ITEMS_KEY]) {\n      const reference = service._makeStorageReference(\n        new Location(bucket, item['name'])\n      );\n      listResult.items.push(reference);\n    }\n  }\n  return listResult;\n}\n\nexport function fromResponseString(\n  service: FirebaseStorageImpl,\n  bucket: string,\n  resourceString: string\n): ListResult | null {\n  const obj = jsonObjectOrNull(resourceString);\n  if (obj === null) {\n    return null;\n  }\n  const resource = obj as unknown as ListResultResponse;\n  return fromBackendResponse(service, bucket, resource);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { StorageError } from './error';\nimport { Headers, Connection, ConnectionType } from './connection';\n\n/**\n * Type for url params stored in RequestInfo.\n */\nexport interface UrlParams {\n  [name: string]: string | number;\n}\n\n/**\n * A function that converts a server response to the API type expected by the\n * SDK.\n *\n * @param I - the type of the backend's network response\n * @param O - the output response type used by the rest of the SDK.\n */\nexport type RequestHandler<I extends ConnectionType, O> = (\n  connection: Connection<I>,\n  response: I\n) => O;\n\n/** A function to handle an error. */\nexport type ErrorHandler = (\n  connection: Connection<ConnectionType>,\n  response: StorageError\n) => StorageError;\n\n/**\n * Contains a fully specified request.\n *\n * @param I - the type of the backend's network response.\n * @param O - the output response type used by the rest of the SDK.\n */\nexport class RequestInfo<I extends ConnectionType, O> {\n  urlParams: UrlParams = {};\n  headers: Headers = {};\n  body: Blob | string | Uint8Array | null = null;\n  errorHandler: ErrorHandler | null = null;\n\n  /**\n   * Called with the current number of bytes uploaded and total size (-1 if not\n   * computable) of the request body (i.e. used to report upload progress).\n   */\n  progressCallback: ((p1: number, p2: number) => void) | null = null;\n  successCodes: number[] = [200];\n  additionalRetryCodes: number[] = [];\n\n  constructor(\n    public url: string,\n    public method: string,\n    /**\n     * Returns the value with which to resolve the request's promise. Only called\n     * if the request is successful. Throw from this function to reject the\n     * returned Request's promise with the thrown error.\n     * Note: The XhrIo passed to this function may be reused after this callback\n     * returns. Do not keep a reference to it in any way.\n     */\n    public handler: RequestHandler<I, O>,\n    public timeout: number\n  ) {}\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Defines methods for interacting with the network.\n */\n\nimport { Metadata } from '../metadata';\nimport { ListResult } from '../list';\nimport { FbsBlob } from './blob';\nimport {\n  StorageError,\n  cannotSliceBlob,\n  unauthenticated,\n  quotaExceeded,\n  unauthorized,\n  objectNotFound,\n  serverFileWrongSize,\n  unknown,\n  unauthorizedApp\n} from './error';\nimport { Location } from './location';\nimport {\n  Mappings,\n  fromResourceString,\n  downloadUrlFromResourceString,\n  toResourceString\n} from './metadata';\nimport { fromResponseString } from './list';\nimport { RequestInfo, UrlParams } from './requestinfo';\nimport { isString } from './type';\nimport { makeUrl } from './url';\nimport { Connection, ConnectionType } from './connection';\nimport { FirebaseStorageImpl } from '../service';\n\n/**\n * Throws the UNKNOWN StorageError if cndn is false.\n */\nexport function handlerCheck(cndn: boolean): void {\n  if (!cndn) {\n    throw unknown();\n  }\n}\n\nexport function metadataHandler(\n  service: FirebaseStorageImpl,\n  mappings: Mappings\n): (p1: Connection<string>, p2: string) => Metadata {\n  function handler(xhr: Connection<string>, text: string): Metadata {\n    const metadata = fromResourceString(service, text, mappings);\n    handlerCheck(metadata !== null);\n    return metadata as Metadata;\n  }\n  return handler;\n}\n\nexport function listHandler(\n  service: FirebaseStorageImpl,\n  bucket: string\n): (p1: Connection<string>, p2: string) => ListResult {\n  function handler(xhr: Connection<string>, text: string): ListResult {\n    const listResult = fromResponseString(service, bucket, text);\n    handlerCheck(listResult !== null);\n    return listResult as ListResult;\n  }\n  return handler;\n}\n\nexport function downloadUrlHandler(\n  service: FirebaseStorageImpl,\n  mappings: Mappings\n): (p1: Connection<string>, p2: string) => string | null {\n  function handler(xhr: Connection<string>, text: string): string | null {\n    const metadata = fromResourceString(service, text, mappings);\n    handlerCheck(metadata !== null);\n    return downloadUrlFromResourceString(\n      metadata as Metadata,\n      text,\n      service.host,\n      service._protocol\n    );\n  }\n  return handler;\n}\n\nexport function sharedErrorHandler(\n  location: Location\n): (p1: Connection<ConnectionType>, p2: StorageError) => StorageError {\n  function errorHandler(\n    xhr: Connection<ConnectionType>,\n    err: StorageError\n  ): StorageError {\n    let newErr: StorageError;\n    if (xhr.getStatus() === 401) {\n      if (\n        // This exact message string is the only consistent part of the\n        // server's error response that identifies it as an App Check error.\n        xhr.getErrorText().includes('Firebase App Check token is invalid')\n      ) {\n        newErr = unauthorizedApp();\n      } else {\n        newErr = unauthenticated();\n      }\n    } else {\n      if (xhr.getStatus() === 402) {\n        newErr = quotaExceeded(location.bucket);\n      } else {\n        if (xhr.getStatus() === 403) {\n          newErr = unauthorized(location.path);\n        } else {\n          newErr = err;\n        }\n      }\n    }\n    newErr.status = xhr.getStatus();\n    newErr.serverResponse = err.serverResponse;\n    return newErr;\n  }\n  return errorHandler;\n}\n\nexport function objectErrorHandler(\n  location: Location\n): (p1: Connection<ConnectionType>, p2: StorageError) => StorageError {\n  const shared = sharedErrorHandler(location);\n\n  function errorHandler(\n    xhr: Connection<ConnectionType>,\n    err: StorageError\n  ): StorageError {\n    let newErr = shared(xhr, err);\n    if (xhr.getStatus() === 404) {\n      newErr = objectNotFound(location.path);\n    }\n    newErr.serverResponse = err.serverResponse;\n    return newErr;\n  }\n  return errorHandler;\n}\n\nexport function getMetadata(\n  service: FirebaseStorageImpl,\n  location: Location,\n  mappings: Mappings\n): RequestInfo<string, Metadata> {\n  const urlPart = location.fullServerUrl();\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'GET';\n  const timeout = service.maxOperationRetryTime;\n  const requestInfo = new RequestInfo(\n    url,\n    method,\n    metadataHandler(service, mappings),\n    timeout\n  );\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function list(\n  service: FirebaseStorageImpl,\n  location: Location,\n  delimiter?: string,\n  pageToken?: string | null,\n  maxResults?: number | null\n): RequestInfo<string, ListResult> {\n  const urlParams: UrlParams = {};\n  if (location.isRoot) {\n    urlParams['prefix'] = '';\n  } else {\n    urlParams['prefix'] = location.path + '/';\n  }\n  if (delimiter && delimiter.length > 0) {\n    urlParams['delimiter'] = delimiter;\n  }\n  if (pageToken) {\n    urlParams['pageToken'] = pageToken;\n  }\n  if (maxResults) {\n    urlParams['maxResults'] = maxResults;\n  }\n  const urlPart = location.bucketOnlyServerUrl();\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'GET';\n  const timeout = service.maxOperationRetryTime;\n  const requestInfo = new RequestInfo(\n    url,\n    method,\n    listHandler(service, location.bucket),\n    timeout\n  );\n  requestInfo.urlParams = urlParams;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\nexport function getBytes<I extends ConnectionType>(\n  service: FirebaseStorageImpl,\n  location: Location,\n  maxDownloadSizeBytes?: number\n): RequestInfo<I, I> {\n  const urlPart = location.fullServerUrl();\n  const url = makeUrl(urlPart, service.host, service._protocol) + '?alt=media';\n  const method = 'GET';\n  const timeout = service.maxOperationRetryTime;\n  const requestInfo = new RequestInfo(\n    url,\n    method,\n    (_: Connection<I>, data: I) => data,\n    timeout\n  );\n  requestInfo.errorHandler = objectErrorHandler(location);\n  if (maxDownloadSizeBytes !== undefined) {\n    requestInfo.headers['Range'] = `bytes=0-${maxDownloadSizeBytes}`;\n    requestInfo.successCodes = [200 /* OK */, 206 /* Partial Content */];\n  }\n  return requestInfo;\n}\n\nexport function getDownloadUrl(\n  service: FirebaseStorageImpl,\n  location: Location,\n  mappings: Mappings\n): RequestInfo<string, string | null> {\n  const urlPart = location.fullServerUrl();\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'GET';\n  const timeout = service.maxOperationRetryTime;\n  const requestInfo = new RequestInfo(\n    url,\n    method,\n    downloadUrlHandler(service, mappings),\n    timeout\n  );\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function updateMetadata(\n  service: FirebaseStorageImpl,\n  location: Location,\n  metadata: Partial<Metadata>,\n  mappings: Mappings\n): RequestInfo<string, Metadata> {\n  const urlPart = location.fullServerUrl();\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'PATCH';\n  const body = toResourceString(metadata, mappings);\n  const headers = { 'Content-Type': 'application/json; charset=utf-8' };\n  const timeout = service.maxOperationRetryTime;\n  const requestInfo = new RequestInfo(\n    url,\n    method,\n    metadataHandler(service, mappings),\n    timeout\n  );\n  requestInfo.headers = headers;\n  requestInfo.body = body;\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function deleteObject(\n  service: FirebaseStorageImpl,\n  location: Location\n): RequestInfo<string, void> {\n  const urlPart = location.fullServerUrl();\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'DELETE';\n  const timeout = service.maxOperationRetryTime;\n\n  function handler(_xhr: Connection<string>, _text: string): void {}\n  const requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.successCodes = [200, 204];\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function determineContentType_(\n  metadata: Metadata | null,\n  blob: FbsBlob | null\n): string {\n  return (\n    (metadata && metadata['contentType']) ||\n    (blob && blob.type()) ||\n    'application/octet-stream'\n  );\n}\n\nexport function metadataForUpload_(\n  location: Location,\n  blob: FbsBlob,\n  metadata?: Metadata | null\n): Metadata {\n  const metadataClone = Object.assign({}, metadata);\n  metadataClone['fullPath'] = location.path;\n  metadataClone['size'] = blob.size();\n  if (!metadataClone['contentType']) {\n    metadataClone['contentType'] = determineContentType_(null, blob);\n  }\n  return metadataClone;\n}\n\n/**\n * Prepare RequestInfo for uploads as Content-Type: multipart.\n */\nexport function multipartUpload(\n  service: FirebaseStorageImpl,\n  location: Location,\n  mappings: Mappings,\n  blob: FbsBlob,\n  metadata?: Metadata | null\n): RequestInfo<string, Metadata> {\n  const urlPart = location.bucketOnlyServerUrl();\n  const headers: { [prop: string]: string } = {\n    'X-Goog-Upload-Protocol': 'multipart'\n  };\n\n  function genBoundary(): string {\n    let str = '';\n    for (let i = 0; i < 2; i++) {\n      str = str + Math.random().toString().slice(2);\n    }\n    return str;\n  }\n  const boundary = genBoundary();\n  headers['Content-Type'] = 'multipart/related; boundary=' + boundary;\n  const metadata_ = metadataForUpload_(location, blob, metadata);\n  const metadataString = toResourceString(metadata_, mappings);\n  const preBlobPart =\n    '--' +\n    boundary +\n    '\\r\\n' +\n    'Content-Type: application/json; charset=utf-8\\r\\n\\r\\n' +\n    metadataString +\n    '\\r\\n--' +\n    boundary +\n    '\\r\\n' +\n    'Content-Type: ' +\n    metadata_['contentType'] +\n    '\\r\\n\\r\\n';\n  const postBlobPart = '\\r\\n--' + boundary + '--';\n  const body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);\n  if (body === null) {\n    throw cannotSliceBlob();\n  }\n  const urlParams: UrlParams = { name: metadata_['fullPath']! };\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'POST';\n  const timeout = service.maxUploadRetryTime;\n  const requestInfo = new RequestInfo(\n    url,\n    method,\n    metadataHandler(service, mappings),\n    timeout\n  );\n  requestInfo.urlParams = urlParams;\n  requestInfo.headers = headers;\n  requestInfo.body = body.uploadData();\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n/**\n * @param current The number of bytes that have been uploaded so far.\n * @param total The total number of bytes in the upload.\n * @param opt_finalized True if the server has finished the upload.\n * @param opt_metadata The upload metadata, should\n *     only be passed if opt_finalized is true.\n */\nexport class ResumableUploadStatus {\n  finalized: boolean;\n  metadata: Metadata | null;\n\n  constructor(\n    public current: number,\n    public total: number,\n    finalized?: boolean,\n    metadata?: Metadata | null\n  ) {\n    this.finalized = !!finalized;\n    this.metadata = metadata || null;\n  }\n}\n\nexport function checkResumeHeader_(\n  xhr: Connection<string>,\n  allowed?: string[]\n): string {\n  let status: string | null = null;\n  try {\n    status = xhr.getResponseHeader('X-Goog-Upload-Status');\n  } catch (e) {\n    handlerCheck(false);\n  }\n  const allowedStatus = allowed || ['active'];\n  handlerCheck(!!status && allowedStatus.indexOf(status) !== -1);\n  return status as string;\n}\n\nexport function createResumableUpload(\n  service: FirebaseStorageImpl,\n  location: Location,\n  mappings: Mappings,\n  blob: FbsBlob,\n  metadata?: Metadata | null\n): RequestInfo<string, string> {\n  const urlPart = location.bucketOnlyServerUrl();\n  const metadataForUpload = metadataForUpload_(location, blob, metadata);\n  const urlParams: UrlParams = { name: metadataForUpload['fullPath']! };\n  const url = makeUrl(urlPart, service.host, service._protocol);\n  const method = 'POST';\n  const headers = {\n    'X-Goog-Upload-Protocol': 'resumable',\n    'X-Goog-Upload-Command': 'start',\n    'X-Goog-Upload-Header-Content-Length': `${blob.size()}`,\n    'X-Goog-Upload-Header-Content-Type': metadataForUpload['contentType']!,\n    'Content-Type': 'application/json; charset=utf-8'\n  };\n  const body = toResourceString(metadataForUpload, mappings);\n  const timeout = service.maxUploadRetryTime;\n\n  function handler(xhr: Connection<string>): string {\n    checkResumeHeader_(xhr);\n    let url;\n    try {\n      url = xhr.getResponseHeader('X-Goog-Upload-URL');\n    } catch (e) {\n      handlerCheck(false);\n    }\n    handlerCheck(isString(url));\n    return url as string;\n  }\n  const requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.urlParams = urlParams;\n  requestInfo.headers = headers;\n  requestInfo.body = body;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n/**\n * @param url From a call to fbs.requests.createResumableUpload.\n */\nexport function getResumableUploadStatus(\n  service: FirebaseStorageImpl,\n  location: Location,\n  url: string,\n  blob: FbsBlob\n): RequestInfo<string, ResumableUploadStatus> {\n  const headers = { 'X-Goog-Upload-Command': 'query' };\n\n  function handler(xhr: Connection<string>): ResumableUploadStatus {\n    const status = checkResumeHeader_(xhr, ['active', 'final']);\n    let sizeString: string | null = null;\n    try {\n      sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received');\n    } catch (e) {\n      handlerCheck(false);\n    }\n\n    if (!sizeString) {\n      // null or empty string\n      handlerCheck(false);\n    }\n\n    const size = Number(sizeString);\n    handlerCheck(!isNaN(size));\n    return new ResumableUploadStatus(size, blob.size(), status === 'final');\n  }\n  const method = 'POST';\n  const timeout = service.maxUploadRetryTime;\n  const requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.headers = headers;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n/**\n * Any uploads via the resumable upload API must transfer a number of bytes\n * that is a multiple of this number.\n */\nexport const RESUMABLE_UPLOAD_CHUNK_SIZE: number = 256 * 1024;\n\n/**\n * @param url From a call to fbs.requests.createResumableUpload.\n * @param chunkSize Number of bytes to upload.\n * @param status The previous status.\n *     If not passed or null, we start from the beginning.\n * @throws fbs.Error If the upload is already complete, the passed in status\n *     has a final size inconsistent with the blob, or the blob cannot be sliced\n *     for upload.\n */\nexport function continueResumableUpload(\n  location: Location,\n  service: FirebaseStorageImpl,\n  url: string,\n  blob: FbsBlob,\n  chunkSize: number,\n  mappings: Mappings,\n  status?: ResumableUploadStatus | null,\n  progressCallback?: ((p1: number, p2: number) => void) | null\n): RequestInfo<string, ResumableUploadStatus> {\n  // TODO(andysoto): standardize on internal asserts\n  // assert(!(opt_status && opt_status.finalized));\n  const status_ = new ResumableUploadStatus(0, 0);\n  if (status) {\n    status_.current = status.current;\n    status_.total = status.total;\n  } else {\n    status_.current = 0;\n    status_.total = blob.size();\n  }\n  if (blob.size() !== status_.total) {\n    throw serverFileWrongSize();\n  }\n  const bytesLeft = status_.total - status_.current;\n  let bytesToUpload = bytesLeft;\n  if (chunkSize > 0) {\n    bytesToUpload = Math.min(bytesToUpload, chunkSize);\n  }\n  const startByte = status_.current;\n  const endByte = startByte + bytesToUpload;\n  let uploadCommand = '';\n  if (bytesToUpload === 0) {\n    uploadCommand = 'finalize';\n  } else if (bytesLeft === bytesToUpload) {\n    uploadCommand = 'upload, finalize';\n  } else {\n    uploadCommand = 'upload';\n  }\n  const headers = {\n    'X-Goog-Upload-Command': uploadCommand,\n    'X-Goog-Upload-Offset': `${status_.current}`\n  };\n  const body = blob.slice(startByte, endByte);\n  if (body === null) {\n    throw cannotSliceBlob();\n  }\n\n  function handler(\n    xhr: Connection<string>,\n    text: string\n  ): ResumableUploadStatus {\n    // TODO(andysoto): Verify the MD5 of each uploaded range:\n    // the 'x-range-md5' header comes back with status code 308 responses.\n    // We'll only be able to bail out though, because you can't re-upload a\n    // range that you previously uploaded.\n    const uploadStatus = checkResumeHeader_(xhr, ['active', 'final']);\n    const newCurrent = status_.current + bytesToUpload;\n    const size = blob.size();\n    let metadata;\n    if (uploadStatus === 'final') {\n      metadata = metadataHandler(service, mappings)(xhr, text);\n    } else {\n      metadata = null;\n    }\n    return new ResumableUploadStatus(\n      newCurrent,\n      size,\n      uploadStatus === 'final',\n      metadata\n    );\n  }\n  const method = 'POST';\n  const timeout = service.maxUploadRetryTime;\n  const requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.headers = headers;\n  requestInfo.body = body.uploadData();\n  requestInfo.progressCallback = progressCallback || null;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Enumerations used for upload tasks.\n */\n\n/**\n * An event that is triggered on a task.\n * @internal\n */\nexport type TaskEvent = string;\n\n/**\n * An event that is triggered on a task.\n * @internal\n */\nexport const TaskEvent = {\n  /**\n   * For this event,\n   * <ul>\n   *   <li>The `next` function is triggered on progress updates and when the\n   *       task is paused/resumed with an `UploadTaskSnapshot` as the first\n   *       argument.</li>\n   *   <li>The `error` function is triggered if the upload is canceled or fails\n   *       for another reason.</li>\n   *   <li>The `complete` function is triggered if the upload completes\n   *       successfully.</li>\n   * </ul>\n   */\n  STATE_CHANGED: 'state_changed'\n};\n\n/**\n * Internal enum for task state.\n */\nexport const enum InternalTaskState {\n  RUNNING = 'running',\n  PAUSING = 'pausing',\n  PAUSED = 'paused',\n  SUCCESS = 'success',\n  CANCELING = 'canceling',\n  CANCELED = 'canceled',\n  ERROR = 'error'\n}\n\n/**\n * Represents the current state of a running upload.\n * @internal\n */\nexport type TaskState = (typeof TaskState)[keyof typeof TaskState];\n\n// type keys = keyof TaskState\n/**\n * Represents the current state of a running upload.\n * @internal\n */\nexport const TaskState = {\n  /** The task is currently transferring data. */\n  RUNNING: 'running',\n\n  /** The task was paused by the user. */\n  PAUSED: 'paused',\n\n  /** The task completed successfully. */\n  SUCCESS: 'success',\n\n  /** The task was canceled. */\n  CANCELED: 'canceled',\n\n  /** The task failed with an error. */\n  ERROR: 'error'\n} as const;\n\nexport function taskStateFromInternalTaskState(\n  state: InternalTaskState\n): TaskState {\n  switch (state) {\n    case InternalTaskState.RUNNING:\n    case InternalTaskState.PAUSING:\n    case InternalTaskState.CANCELING:\n      return TaskState.RUNNING;\n    case InternalTaskState.PAUSED:\n      return TaskState.PAUSED;\n    case InternalTaskState.SUCCESS:\n      return TaskState.SUCCESS;\n    case InternalTaskState.CANCELED:\n      return TaskState.CANCELED;\n    case InternalTaskState.ERROR:\n      return TaskState.ERROR;\n    default:\n      // TODO(andysoto): assert(false);\n      return TaskState.ERROR;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { isFunction } from './type';\nimport { StorageError } from './error';\n\n/**\n * Function that is called once for each value in a stream of values.\n */\nexport type NextFn<T> = (value: T) => void;\n\n/**\n * A function that is called with a `StorageError`\n * if the event stream ends due to an error.\n */\nexport type ErrorFn = (error: StorageError) => void;\n\n/**\n * A function that is called if the event stream ends normally.\n */\nexport type CompleteFn = () => void;\n\n/**\n * Unsubscribes from a stream.\n */\nexport type Unsubscribe = () => void;\n\n/**\n * An observer identical to the `Observer` defined in packages/util except the\n * error passed into the ErrorFn is specifically a `StorageError`.\n */\nexport interface StorageObserver<T> {\n  /**\n   * Function that is called once for each value in the event stream.\n   */\n  next?: NextFn<T>;\n  /**\n   * A function that is called with a `StorageError`\n   * if the event stream ends due to an error.\n   */\n  error?: ErrorFn;\n  /**\n   * A function that is called if the event stream ends normally.\n   */\n  complete?: CompleteFn;\n}\n\n/**\n * Subscribes to an event stream.\n */\nexport type Subscribe<T> = (\n  next?: NextFn<T> | StorageObserver<T>,\n  error?: ErrorFn,\n  complete?: CompleteFn\n) => Unsubscribe;\n\nexport class Observer<T> implements StorageObserver<T> {\n  next?: NextFn<T>;\n  error?: ErrorFn;\n  complete?: CompleteFn;\n\n  constructor(\n    nextOrObserver?: NextFn<T> | StorageObserver<T>,\n    error?: ErrorFn,\n    complete?: CompleteFn\n  ) {\n    const asFunctions =\n      isFunction(nextOrObserver) || error != null || complete != null;\n    if (asFunctions) {\n      this.next = nextOrObserver as NextFn<T>;\n      this.error = error ?? undefined;\n      this.complete = complete ?? undefined;\n    } else {\n      const observer = nextOrObserver as {\n        next?: NextFn<T>;\n        error?: ErrorFn;\n        complete?: CompleteFn;\n      };\n      this.next = observer.next;\n      this.error = observer.error;\n      this.complete = observer.complete;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Returns a function that invokes f with its arguments asynchronously as a\n * microtask, i.e. as soon as possible after the current script returns back\n * into browser code.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function async(f: Function): Function {\n  return (...argsToForward: unknown[]) => {\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    Promise.resolve().then(() => f(...argsToForward));\n  };\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isCloudWorkstation } from '@firebase/util';\nimport {\n  Connection,\n  ConnectionType,\n  ErrorCode\n} from '../../implementation/connection';\nimport { internalError } from '../../implementation/error';\n\n/** An override for the text-based Connection. Used in tests. */\nlet textFactoryOverride: (() => Connection<string>) | null = null;\n\n/**\n * Network layer that works in Node.\n *\n * This network implementation should not be used in browsers as it does not\n * support progress updates.\n */\nabstract class FetchConnection<T extends ConnectionType>\n  implements Connection<T>\n{\n  protected errorCode_: ErrorCode;\n  protected statusCode_: number | undefined;\n  protected body_: ArrayBuffer | undefined;\n  protected errorText_ = '';\n  protected headers_: Headers | undefined;\n  protected sent_: boolean = false;\n\n  constructor() {\n    this.errorCode_ = ErrorCode.NO_ERROR;\n  }\n\n  async send(\n    url: string,\n    method: string,\n    isUsingEmulator: boolean,\n    body?: NodeJS.ArrayBufferView | Blob | string,\n    headers?: Record<string, string>\n  ): Promise<void> {\n    if (this.sent_) {\n      throw internalError('cannot .send() more than once');\n    }\n    this.sent_ = true;\n\n    try {\n      const response = await newFetch(\n        url,\n        method,\n        isUsingEmulator,\n        headers,\n        body\n      );\n      this.headers_ = response.headers;\n      this.statusCode_ = response.status;\n      this.errorCode_ = ErrorCode.NO_ERROR;\n      this.body_ = await response.arrayBuffer();\n    } catch (e) {\n      this.errorText_ = (e as Error)?.message;\n      // emulate XHR which sets status to 0 when encountering a network error\n      this.statusCode_ = 0;\n      this.errorCode_ = ErrorCode.NETWORK_ERROR;\n    }\n  }\n\n  getErrorCode(): ErrorCode {\n    if (this.errorCode_ === undefined) {\n      throw internalError('cannot .getErrorCode() before receiving response');\n    }\n    return this.errorCode_;\n  }\n\n  getStatus(): number {\n    if (this.statusCode_ === undefined) {\n      throw internalError('cannot .getStatus() before receiving response');\n    }\n    return this.statusCode_;\n  }\n\n  abstract getResponse(): T;\n\n  getErrorText(): string {\n    return this.errorText_;\n  }\n\n  abort(): void {\n    // Not supported\n  }\n\n  getResponseHeader(header: string): string | null {\n    if (!this.headers_) {\n      throw internalError(\n        'cannot .getResponseHeader() before receiving response'\n      );\n    }\n    return this.headers_.get(header);\n  }\n\n  addUploadProgressListener(listener: (p1: ProgressEvent) => void): void {\n    // Not supported\n  }\n\n  removeUploadProgressListener(listener: (p1: ProgressEvent) => void): void {\n    // Not supported\n  }\n}\n\nexport class FetchTextConnection extends FetchConnection<string> {\n  getResponse(): string {\n    if (!this.body_) {\n      throw internalError('cannot .getResponse() before receiving response');\n    }\n    return Buffer.from(this.body_).toString('utf-8');\n  }\n}\n\nexport function newTextConnection(): Connection<string> {\n  return textFactoryOverride\n    ? textFactoryOverride()\n    : new FetchTextConnection();\n}\n\nexport class FetchBytesConnection extends FetchConnection<ArrayBuffer> {\n  getResponse(): ArrayBuffer {\n    if (!this.body_) {\n      throw internalError('cannot .getResponse() before sending');\n    }\n    return this.body_;\n  }\n}\n\nexport function newBytesConnection(): Connection<ArrayBuffer> {\n  return new FetchBytesConnection();\n}\n\nexport class FetchStreamConnection extends FetchConnection<\n  ReadableStream<Uint8Array>\n> {\n  private stream_: ReadableStream<Uint8Array> | null = null;\n\n  async send(\n    url: string,\n    method: string,\n    isUsingEmulator: boolean,\n    body?: NodeJS.ArrayBufferView | Blob | string,\n    headers?: Record<string, string>\n  ): Promise<void> {\n    if (this.sent_) {\n      throw internalError('cannot .send() more than once');\n    }\n    this.sent_ = true;\n\n    try {\n      const response = await newFetch(\n        url,\n        method,\n        isUsingEmulator,\n        headers,\n        body\n      );\n      this.headers_ = response.headers;\n      this.statusCode_ = response.status;\n      this.errorCode_ = ErrorCode.NO_ERROR;\n      this.stream_ = response.body as ReadableStream<Uint8Array>;\n    } catch (e) {\n      this.errorText_ = (e as Error)?.message;\n      // emulate XHR which sets status to 0 when encountering a network error\n      this.statusCode_ = 0;\n      this.errorCode_ = ErrorCode.NETWORK_ERROR;\n    }\n  }\n\n  getResponse(): ReadableStream {\n    if (!this.stream_) {\n      throw internalError('cannot .getResponse() before sending');\n    }\n    return this.stream_;\n  }\n}\n\nfunction newFetch(\n  url: string,\n  method: string,\n  isUsingEmulator: boolean,\n  headers?: Record<string, string>,\n  body?: NodeJS.ArrayBufferView | Blob | string\n): Promise<Response> {\n  const fetchArgs: RequestInit = {\n    method,\n    headers: headers || {},\n    body: body as NodeJS.ArrayBufferView | string\n  };\n  if (isCloudWorkstation(url) && isUsingEmulator) {\n    fetchArgs.credentials = 'include';\n  }\n  return fetch(url, fetchArgs);\n}\n\nexport function newStreamConnection(): Connection<ReadableStream<Uint8Array>> {\n  return new FetchStreamConnection();\n}\n\nexport function newBlobConnection(): Connection<Blob> {\n  throw new Error('Blobs are not supported on Node');\n}\n\nexport function injectTestConnection(\n  factory: (() => Connection<string>) | null\n): void {\n  textFactoryOverride = factory;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Defines types for interacting with blob transfer tasks.\n */\n\nimport { FbsBlob } from './implementation/blob';\nimport {\n  canceled,\n  StorageErrorCode,\n  StorageError,\n  retryLimitExceeded\n} from './implementation/error';\nimport {\n  InternalTaskState,\n  TaskEvent,\n  TaskState,\n  taskStateFromInternalTaskState\n} from './implementation/taskenums';\nimport { Metadata } from './metadata';\nimport {\n  Observer,\n  Subscribe,\n  Unsubscribe,\n  StorageObserver as StorageObserverInternal,\n  NextFn\n} from './implementation/observer';\nimport { Request } from './implementation/request';\nimport { UploadTaskSnapshot, StorageObserver } from './public-types';\nimport { async as fbsAsync } from './implementation/async';\nimport { Mappings, getMappings } from './implementation/metadata';\nimport {\n  createResumableUpload,\n  getResumableUploadStatus,\n  RESUMABLE_UPLOAD_CHUNK_SIZE,\n  ResumableUploadStatus,\n  continueResumableUpload,\n  getMetadata,\n  multipartUpload\n} from './implementation/requests';\nimport { Reference } from './reference';\nimport { newTextConnection } from './platform/connection';\nimport { isRetryStatusCode } from './implementation/utils';\nimport { CompleteFn } from '@firebase/util';\nimport { DEFAULT_MIN_SLEEP_TIME_MILLIS } from './implementation/constants';\n\n/**\n * Represents a blob being uploaded. Can be used to pause/resume/cancel the\n * upload and manage callbacks for various events.\n * @internal\n */\nexport class UploadTask {\n  private _ref: Reference;\n  /**\n   * The data to be uploaded.\n   */\n  _blob: FbsBlob;\n  /**\n   * Metadata related to the upload.\n   */\n  _metadata: Metadata | null;\n  private _mappings: Mappings;\n  /**\n   * Number of bytes transferred so far.\n   */\n  _transferred: number = 0;\n  private _needToFetchStatus: boolean = false;\n  private _needToFetchMetadata: boolean = false;\n  private _observers: Array<StorageObserverInternal<UploadTaskSnapshot>> = [];\n  private _resumable: boolean;\n  /**\n   * Upload state.\n   */\n  _state: InternalTaskState;\n  private _error?: StorageError = undefined;\n  private _uploadUrl?: string = undefined;\n  private _request?: Request<unknown> = undefined;\n  private _chunkMultiplier: number = 1;\n  private _errorHandler: (p1: StorageError) => void;\n  private _metadataErrorHandler: (p1: StorageError) => void;\n  private _resolve?: (p1: UploadTaskSnapshot) => void = undefined;\n  private _reject?: (p1: StorageError) => void = undefined;\n  private pendingTimeout?: ReturnType<typeof setTimeout>;\n  private _promise: Promise<UploadTaskSnapshot>;\n\n  private sleepTime: number;\n\n  private maxSleepTime: number;\n\n  isExponentialBackoffExpired(): boolean {\n    return this.sleepTime > this.maxSleepTime;\n  }\n\n  /**\n   * @param ref - The firebaseStorage.Reference object this task came\n   *     from, untyped to avoid cyclic dependencies.\n   * @param blob - The blob to upload.\n   */\n  constructor(ref: Reference, blob: FbsBlob, metadata: Metadata | null = null) {\n    this._ref = ref;\n    this._blob = blob;\n    this._metadata = metadata;\n    this._mappings = getMappings();\n    this._resumable = this._shouldDoResumable(this._blob);\n    this._state = InternalTaskState.RUNNING;\n    this._errorHandler = error => {\n      this._request = undefined;\n      this._chunkMultiplier = 1;\n      if (error._codeEquals(StorageErrorCode.CANCELED)) {\n        this._needToFetchStatus = true;\n        this.completeTransitions_();\n      } else {\n        const backoffExpired = this.isExponentialBackoffExpired();\n        if (isRetryStatusCode(error.status, [])) {\n          if (backoffExpired) {\n            error = retryLimitExceeded();\n          } else {\n            this.sleepTime = Math.max(\n              this.sleepTime * 2,\n              DEFAULT_MIN_SLEEP_TIME_MILLIS\n            );\n            this._needToFetchStatus = true;\n            this.completeTransitions_();\n            return;\n          }\n        }\n        this._error = error;\n        this._transition(InternalTaskState.ERROR);\n      }\n    };\n    this._metadataErrorHandler = error => {\n      this._request = undefined;\n      if (error._codeEquals(StorageErrorCode.CANCELED)) {\n        this.completeTransitions_();\n      } else {\n        this._error = error;\n        this._transition(InternalTaskState.ERROR);\n      }\n    };\n    this.sleepTime = 0;\n    this.maxSleepTime = this._ref.storage.maxUploadRetryTime;\n    this._promise = new Promise((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n      this._start();\n    });\n\n    // Prevent uncaught rejections on the internal promise from bubbling out\n    // to the top level with a dummy handler.\n    this._promise.then(null, () => {});\n  }\n\n  private _makeProgressCallback(): (p1: number, p2: number) => void {\n    const sizeBefore = this._transferred;\n    return loaded => this._updateProgress(sizeBefore + loaded);\n  }\n\n  private _shouldDoResumable(blob: FbsBlob): boolean {\n    return blob.size() > 256 * 1024;\n  }\n\n  private _start(): void {\n    if (this._state !== InternalTaskState.RUNNING) {\n      // This can happen if someone pauses us in a resume callback, for example.\n      return;\n    }\n    if (this._request !== undefined) {\n      return;\n    }\n    if (this._resumable) {\n      if (this._uploadUrl === undefined) {\n        this._createResumable();\n      } else {\n        if (this._needToFetchStatus) {\n          this._fetchStatus();\n        } else {\n          if (this._needToFetchMetadata) {\n            // Happens if we miss the metadata on upload completion.\n            this._fetchMetadata();\n          } else {\n            this.pendingTimeout = setTimeout(() => {\n              this.pendingTimeout = undefined;\n              this._continueUpload();\n            }, this.sleepTime);\n          }\n        }\n      }\n    } else {\n      this._oneShotUpload();\n    }\n  }\n\n  private _resolveToken(\n    callback: (authToken: string | null, appCheckToken: string | null) => void\n  ): void {\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    Promise.all([\n      this._ref.storage._getAuthToken(),\n      this._ref.storage._getAppCheckToken()\n    ]).then(([authToken, appCheckToken]) => {\n      switch (this._state) {\n        case InternalTaskState.RUNNING:\n          callback(authToken, appCheckToken);\n          break;\n        case InternalTaskState.CANCELING:\n          this._transition(InternalTaskState.CANCELED);\n          break;\n        case InternalTaskState.PAUSING:\n          this._transition(InternalTaskState.PAUSED);\n          break;\n        default:\n      }\n    });\n  }\n\n  // TODO(andysoto): assert false\n\n  private _createResumable(): void {\n    this._resolveToken((authToken, appCheckToken) => {\n      const requestInfo = createResumableUpload(\n        this._ref.storage,\n        this._ref._location,\n        this._mappings,\n        this._blob,\n        this._metadata\n      );\n      const createRequest = this._ref.storage._makeRequest(\n        requestInfo,\n        newTextConnection,\n        authToken,\n        appCheckToken\n      );\n      this._request = createRequest;\n      createRequest.getPromise().then((url: string) => {\n        this._request = undefined;\n        this._uploadUrl = url;\n        this._needToFetchStatus = false;\n        this.completeTransitions_();\n      }, this._errorHandler);\n    });\n  }\n\n  private _fetchStatus(): void {\n    // TODO(andysoto): assert(this.uploadUrl_ !== null);\n    const url = this._uploadUrl as string;\n    this._resolveToken((authToken, appCheckToken) => {\n      const requestInfo = getResumableUploadStatus(\n        this._ref.storage,\n        this._ref._location,\n        url,\n        this._blob\n      );\n      const statusRequest = this._ref.storage._makeRequest(\n        requestInfo,\n        newTextConnection,\n        authToken,\n        appCheckToken\n      );\n      this._request = statusRequest;\n      statusRequest.getPromise().then(status => {\n        status = status as ResumableUploadStatus;\n        this._request = undefined;\n        this._updateProgress(status.current);\n        this._needToFetchStatus = false;\n        if (status.finalized) {\n          this._needToFetchMetadata = true;\n        }\n        this.completeTransitions_();\n      }, this._errorHandler);\n    });\n  }\n\n  private _continueUpload(): void {\n    const chunkSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;\n    const status = new ResumableUploadStatus(\n      this._transferred,\n      this._blob.size()\n    );\n\n    // TODO(andysoto): assert(this.uploadUrl_ !== null);\n    const url = this._uploadUrl as string;\n    this._resolveToken((authToken, appCheckToken) => {\n      let requestInfo;\n      try {\n        requestInfo = continueResumableUpload(\n          this._ref._location,\n          this._ref.storage,\n          url,\n          this._blob,\n          chunkSize,\n          this._mappings,\n          status,\n          this._makeProgressCallback()\n        );\n      } catch (e) {\n        this._error = e as StorageError;\n        this._transition(InternalTaskState.ERROR);\n        return;\n      }\n      const uploadRequest = this._ref.storage._makeRequest(\n        requestInfo,\n        newTextConnection,\n        authToken,\n        appCheckToken,\n        /*retry=*/ false // Upload requests should not be retried as each retry should be preceded by another query request. Which is handled in this file.\n      );\n      this._request = uploadRequest;\n      uploadRequest.getPromise().then((newStatus: ResumableUploadStatus) => {\n        this._increaseMultiplier();\n        this._request = undefined;\n        this._updateProgress(newStatus.current);\n        if (newStatus.finalized) {\n          this._metadata = newStatus.metadata;\n          this._transition(InternalTaskState.SUCCESS);\n        } else {\n          this.completeTransitions_();\n        }\n      }, this._errorHandler);\n    });\n  }\n\n  private _increaseMultiplier(): void {\n    const currentSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;\n\n    // Max chunk size is 32M.\n    if (currentSize * 2 < 32 * 1024 * 1024) {\n      this._chunkMultiplier *= 2;\n    }\n  }\n\n  private _fetchMetadata(): void {\n    this._resolveToken((authToken, appCheckToken) => {\n      const requestInfo = getMetadata(\n        this._ref.storage,\n        this._ref._location,\n        this._mappings\n      );\n      const metadataRequest = this._ref.storage._makeRequest(\n        requestInfo,\n        newTextConnection,\n        authToken,\n        appCheckToken\n      );\n      this._request = metadataRequest;\n      metadataRequest.getPromise().then(metadata => {\n        this._request = undefined;\n        this._metadata = metadata;\n        this._transition(InternalTaskState.SUCCESS);\n      }, this._metadataErrorHandler);\n    });\n  }\n\n  private _oneShotUpload(): void {\n    this._resolveToken((authToken, appCheckToken) => {\n      const requestInfo = multipartUpload(\n        this._ref.storage,\n        this._ref._location,\n        this._mappings,\n        this._blob,\n        this._metadata\n      );\n      const multipartRequest = this._ref.storage._makeRequest(\n        requestInfo,\n        newTextConnection,\n        authToken,\n        appCheckToken\n      );\n      this._request = multipartRequest;\n      multipartRequest.getPromise().then(metadata => {\n        this._request = undefined;\n        this._metadata = metadata;\n        this._updateProgress(this._blob.size());\n        this._transition(InternalTaskState.SUCCESS);\n      }, this._errorHandler);\n    });\n  }\n\n  private _updateProgress(transferred: number): void {\n    const old = this._transferred;\n    this._transferred = transferred;\n\n    // A progress update can make the \"transferred\" value smaller (e.g. a\n    // partial upload not completed by server, after which the \"transferred\"\n    // value may reset to the value at the beginning of the request).\n    if (this._transferred !== old) {\n      this._notifyObservers();\n    }\n  }\n\n  private _transition(state: InternalTaskState): void {\n    if (this._state === state) {\n      return;\n    }\n    switch (state) {\n      case InternalTaskState.CANCELING:\n      case InternalTaskState.PAUSING:\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING ||\n        //        this.state_ === InternalTaskState.PAUSING);\n        this._state = state;\n        if (this._request !== undefined) {\n          this._request.cancel();\n        } else if (this.pendingTimeout) {\n          clearTimeout(this.pendingTimeout);\n          this.pendingTimeout = undefined;\n          this.completeTransitions_();\n        }\n        break;\n      case InternalTaskState.RUNNING:\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.PAUSED ||\n        //        this.state_ === InternalTaskState.PAUSING);\n        const wasPaused = this._state === InternalTaskState.PAUSED;\n        this._state = state;\n        if (wasPaused) {\n          this._notifyObservers();\n          this._start();\n        }\n        break;\n      case InternalTaskState.PAUSED:\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.PAUSING);\n        this._state = state;\n        this._notifyObservers();\n        break;\n      case InternalTaskState.CANCELED:\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.PAUSED ||\n        //        this.state_ === InternalTaskState.CANCELING);\n        this._error = canceled();\n        this._state = state;\n        this._notifyObservers();\n        break;\n      case InternalTaskState.ERROR:\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING ||\n        //        this.state_ === InternalTaskState.PAUSING ||\n        //        this.state_ === InternalTaskState.CANCELING);\n        this._state = state;\n        this._notifyObservers();\n        break;\n      case InternalTaskState.SUCCESS:\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING ||\n        //        this.state_ === InternalTaskState.PAUSING ||\n        //        this.state_ === InternalTaskState.CANCELING);\n        this._state = state;\n        this._notifyObservers();\n        break;\n      default: // Ignore\n    }\n  }\n\n  private completeTransitions_(): void {\n    switch (this._state) {\n      case InternalTaskState.PAUSING:\n        this._transition(InternalTaskState.PAUSED);\n        break;\n      case InternalTaskState.CANCELING:\n        this._transition(InternalTaskState.CANCELED);\n        break;\n      case InternalTaskState.RUNNING:\n        this._start();\n        break;\n      default:\n        // TODO(andysoto): assert(false);\n        break;\n    }\n  }\n\n  /**\n   * A snapshot of the current task state.\n   */\n  get snapshot(): UploadTaskSnapshot {\n    const externalState = taskStateFromInternalTaskState(this._state);\n    return {\n      bytesTransferred: this._transferred,\n      totalBytes: this._blob.size(),\n      state: externalState,\n      metadata: this._metadata!,\n      task: this,\n      ref: this._ref\n    };\n  }\n\n  /**\n   * Adds a callback for an event.\n   * @param type - The type of event to listen for.\n   * @param nextOrObserver -\n   *     The `next` function, which gets called for each item in\n   *     the event stream, or an observer object with some or all of these three\n   *     properties (`next`, `error`, `complete`).\n   * @param error - A function that gets called with a `StorageError`\n   *     if the event stream ends due to an error.\n   * @param completed - A function that gets called if the\n   *     event stream ends normally.\n   * @returns\n   *     If only the event argument is passed, returns a function you can use to\n   *     add callbacks (see the examples above). If more than just the event\n   *     argument is passed, returns a function you can call to unregister the\n   *     callbacks.\n   */\n  on(\n    type: TaskEvent,\n    nextOrObserver?:\n      | StorageObserver<UploadTaskSnapshot>\n      | null\n      | ((snapshot: UploadTaskSnapshot) => unknown),\n    error?: ((a: StorageError) => unknown) | null,\n    completed?: CompleteFn | null\n  ): Unsubscribe | Subscribe<UploadTaskSnapshot> {\n    // Note: `type` isn't being used. Its type is also incorrect. TaskEvent should not be a string.\n    const observer = new Observer(\n      (nextOrObserver as\n        | StorageObserverInternal<UploadTaskSnapshot>\n        | NextFn<UploadTaskSnapshot>) || undefined,\n      error || undefined,\n      completed || undefined\n    );\n    this._addObserver(observer);\n    return () => {\n      this._removeObserver(observer);\n    };\n  }\n\n  /**\n   * This object behaves like a Promise, and resolves with its snapshot data\n   * when the upload completes.\n   * @param onFulfilled - The fulfillment callback. Promise chaining works as normal.\n   * @param onRejected - The rejection callback.\n   */\n  then<U>(\n    onFulfilled?: ((value: UploadTaskSnapshot) => U | Promise<U>) | null,\n    onRejected?: ((error: StorageError) => U | Promise<U>) | null\n  ): Promise<U> {\n    // These casts are needed so that TypeScript can infer the types of the\n    // resulting Promise.\n    return this._promise.then<U>(\n      onFulfilled as (value: UploadTaskSnapshot) => U | Promise<U>,\n      onRejected as ((error: unknown) => Promise<never>) | null\n    );\n  }\n\n  /**\n   * Equivalent to calling `then(null, onRejected)`.\n   */\n  catch<T>(onRejected: (p1: StorageError) => T | Promise<T>): Promise<T> {\n    return this.then(null, onRejected);\n  }\n\n  /**\n   * Adds the given observer.\n   */\n  private _addObserver(observer: Observer<UploadTaskSnapshot>): void {\n    this._observers.push(observer);\n    this._notifyObserver(observer);\n  }\n\n  /**\n   * Removes the given observer.\n   */\n  private _removeObserver(observer: Observer<UploadTaskSnapshot>): void {\n    const i = this._observers.indexOf(observer);\n    if (i !== -1) {\n      this._observers.splice(i, 1);\n    }\n  }\n\n  private _notifyObservers(): void {\n    this._finishPromise();\n    const observers = this._observers.slice();\n    observers.forEach(observer => {\n      this._notifyObserver(observer);\n    });\n  }\n\n  private _finishPromise(): void {\n    if (this._resolve !== undefined) {\n      let triggered = true;\n      switch (taskStateFromInternalTaskState(this._state)) {\n        case TaskState.SUCCESS:\n          fbsAsync(this._resolve.bind(null, this.snapshot))();\n          break;\n        case TaskState.CANCELED:\n        case TaskState.ERROR:\n          const toCall = this._reject as (p1: StorageError) => void;\n          fbsAsync(toCall.bind(null, this._error as StorageError))();\n          break;\n        default:\n          triggered = false;\n          break;\n      }\n      if (triggered) {\n        this._resolve = undefined;\n        this._reject = undefined;\n      }\n    }\n  }\n\n  private _notifyObserver(observer: Observer<UploadTaskSnapshot>): void {\n    const externalState = taskStateFromInternalTaskState(this._state);\n    switch (externalState) {\n      case TaskState.RUNNING:\n      case TaskState.PAUSED:\n        if (observer.next) {\n          fbsAsync(observer.next.bind(observer, this.snapshot))();\n        }\n        break;\n      case TaskState.SUCCESS:\n        if (observer.complete) {\n          fbsAsync(observer.complete.bind(observer))();\n        }\n        break;\n      case TaskState.CANCELED:\n      case TaskState.ERROR:\n        if (observer.error) {\n          fbsAsync(\n            observer.error.bind(observer, this._error as StorageError)\n          )();\n        }\n        break;\n      default:\n        // TODO(andysoto): assert(false);\n        if (observer.error) {\n          fbsAsync(\n            observer.error.bind(observer, this._error as StorageError)\n          )();\n        }\n    }\n  }\n\n  /**\n   * Resumes a paused task. Has no effect on a currently running or failed task.\n   * @returns True if the operation took effect, false if ignored.\n   */\n  resume(): boolean {\n    const valid =\n      this._state === InternalTaskState.PAUSED ||\n      this._state === InternalTaskState.PAUSING;\n    if (valid) {\n      this._transition(InternalTaskState.RUNNING);\n    }\n    return valid;\n  }\n\n  /**\n   * Pauses a currently running task. Has no effect on a paused or failed task.\n   * @returns True if the operation took effect, false if ignored.\n   */\n  pause(): boolean {\n    const valid = this._state === InternalTaskState.RUNNING;\n    if (valid) {\n      this._transition(InternalTaskState.PAUSING);\n    }\n    return valid;\n  }\n\n  /**\n   * Cancels a currently running or paused task. Has no effect on a complete or\n   * failed task.\n   * @returns True if the operation took effect, false if ignored.\n   */\n  cancel(): boolean {\n    const valid =\n      this._state === InternalTaskState.RUNNING ||\n      this._state === InternalTaskState.PAUSING;\n    if (valid) {\n      this._transition(InternalTaskState.CANCELING);\n    }\n    return valid;\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Defines the Firebase StorageReference class.\n */\n\nimport { FbsBlob } from './implementation/blob';\nimport { Location } from './implementation/location';\nimport { getMappings } from './implementation/metadata';\nimport { child, lastComponent, parent } from './implementation/path';\nimport {\n  deleteObject as requestsDeleteObject,\n  getBytes,\n  getDownloadUrl as requestsGetDownloadUrl,\n  getMetadata as requestsGetMetadata,\n  list as requestsList,\n  multipartUpload,\n  updateMetadata as requestsUpdateMetadata\n} from './implementation/requests';\nimport { ListOptions, UploadResult } from './public-types';\nimport { dataFromString, StringFormat } from './implementation/string';\nimport { Metadata } from './metadata';\nimport { FirebaseStorageImpl } from './service';\nimport { ListResult } from './list';\nimport { UploadTask } from './task';\nimport { invalidRootOperation, noDownloadURL } from './implementation/error';\nimport { validateNumber } from './implementation/type';\nimport {\n  newBlobConnection,\n  newBytesConnection,\n  newStreamConnection,\n  newTextConnection\n} from './platform/connection';\nimport { RequestInfo } from './implementation/requestinfo';\n\n/**\n * Provides methods to interact with a bucket in the Firebase Storage service.\n * @internal\n * @param _location - An fbs.location, or the URL at\n *     which to base this object, in one of the following forms:\n *         gs://<bucket>/<object-path>\n *         http[s]://firebasestorage.googleapis.com/\n *                     <api-version>/b/<bucket>/o/<object-path>\n *     Any query or fragment strings will be ignored in the http[s]\n *     format. If no value is passed, the storage object will use a URL based on\n *     the project ID of the base firebase.App instance.\n */\nexport class Reference {\n  _location: Location;\n\n  constructor(\n    private _service: FirebaseStorageImpl,\n    location: string | Location\n  ) {\n    if (location instanceof Location) {\n      this._location = location;\n    } else {\n      this._location = Location.makeFromUrl(location, _service.host);\n    }\n  }\n\n  /**\n   * Returns the URL for the bucket and path this object references,\n   *     in the form gs://<bucket>/<object-path>\n   * @override\n   */\n  toString(): string {\n    return 'gs://' + this._location.bucket + '/' + this._location.path;\n  }\n\n  protected _newRef(\n    service: FirebaseStorageImpl,\n    location: Location\n  ): Reference {\n    return new Reference(service, location);\n  }\n\n  /**\n   * A reference to the root of this object's bucket.\n   */\n  get root(): Reference {\n    const location = new Location(this._location.bucket, '');\n    return this._newRef(this._service, location);\n  }\n\n  /**\n   * The name of the bucket containing this reference's object.\n   */\n  get bucket(): string {\n    return this._location.bucket;\n  }\n\n  /**\n   * The full path of this object.\n   */\n  get fullPath(): string {\n    return this._location.path;\n  }\n\n  /**\n   * The short name of this object, which is the last component of the full path.\n   * For example, if fullPath is 'full/path/image.png', name is 'image.png'.\n   */\n  get name(): string {\n    return lastComponent(this._location.path);\n  }\n\n  /**\n   * The `StorageService` instance this `StorageReference` is associated with.\n   */\n  get storage(): FirebaseStorageImpl {\n    return this._service;\n  }\n\n  /**\n   * A `StorageReference` pointing to the parent location of this `StorageReference`, or null if\n   * this reference is the root.\n   */\n  get parent(): Reference | null {\n    const newPath = parent(this._location.path);\n    if (newPath === null) {\n      return null;\n    }\n    const location = new Location(this._location.bucket, newPath);\n    return new Reference(this._service, location);\n  }\n\n  /**\n   * Utility function to throw an error in methods that do not accept a root reference.\n   */\n  _throwIfRoot(name: string): void {\n    if (this._location.path === '') {\n      throw invalidRootOperation(name);\n    }\n  }\n}\n\n/**\n * Download the bytes at the object's location.\n * @returns A Promise containing the downloaded bytes.\n */\nexport function getBytesInternal(\n  ref: Reference,\n  maxDownloadSizeBytes?: number\n): Promise<ArrayBuffer> {\n  ref._throwIfRoot('getBytes');\n  const requestInfo = getBytes(\n    ref.storage,\n    ref._location,\n    maxDownloadSizeBytes\n  );\n  return ref.storage\n    .makeRequestWithTokens(requestInfo, newBytesConnection)\n    .then(bytes =>\n      maxDownloadSizeBytes !== undefined\n        ? // GCS may not honor the Range header for small files\n          (bytes as ArrayBuffer).slice(0, maxDownloadSizeBytes)\n        : (bytes as ArrayBuffer)\n    );\n}\n\n/**\n * Download the bytes at the object's location.\n * @returns A Promise containing the downloaded blob.\n */\nexport function getBlobInternal(\n  ref: Reference,\n  maxDownloadSizeBytes?: number\n): Promise<Blob> {\n  ref._throwIfRoot('getBlob');\n  const requestInfo = getBytes(\n    ref.storage,\n    ref._location,\n    maxDownloadSizeBytes\n  );\n  return ref.storage\n    .makeRequestWithTokens(requestInfo, newBlobConnection)\n    .then(blob =>\n      maxDownloadSizeBytes !== undefined\n        ? // GCS may not honor the Range header for small files\n          (blob as Blob).slice(0, maxDownloadSizeBytes)\n        : (blob as Blob)\n    );\n}\n\n/** Stream the bytes at the object's location. */\nexport function getStreamInternal(\n  ref: Reference,\n  maxDownloadSizeBytes?: number\n): ReadableStream {\n  ref._throwIfRoot('getStream');\n  const requestInfo: RequestInfo<ReadableStream, ReadableStream> = getBytes(\n    ref.storage,\n    ref._location,\n    maxDownloadSizeBytes\n  );\n\n  // Transforms the stream so that only `maxDownloadSizeBytes` bytes are piped to the result\n  const newMaxSizeTransform = (n: number): Transformer => {\n    let missingBytes = n;\n    return {\n      transform(chunk, controller: TransformStreamDefaultController) {\n        // GCS may not honor the Range header for small files\n        if (chunk.length < missingBytes) {\n          controller.enqueue(chunk);\n          missingBytes -= chunk.length;\n        } else {\n          controller.enqueue(chunk.slice(0, missingBytes));\n          controller.terminate();\n        }\n      }\n    };\n  };\n\n  const result =\n    maxDownloadSizeBytes !== undefined\n      ? new TransformStream(newMaxSizeTransform(maxDownloadSizeBytes))\n      : new TransformStream(); // The default transformer forwards all chunks to its readable side\n\n  ref.storage\n    .makeRequestWithTokens(requestInfo, newStreamConnection)\n    .then(readableStream => readableStream.pipeThrough(result))\n    .catch(err => result.writable.abort(err));\n\n  return result.readable;\n}\n\n/**\n * Uploads data to this object's location.\n * The upload is not resumable.\n *\n * @param ref - StorageReference where data should be uploaded.\n * @param data - The data to upload.\n * @param metadata - Metadata for the newly uploaded data.\n * @returns A Promise containing an UploadResult\n */\nexport function uploadBytes(\n  ref: Reference,\n  data: Blob | Uint8Array | ArrayBuffer,\n  metadata?: Metadata\n): Promise<UploadResult> {\n  ref._throwIfRoot('uploadBytes');\n  const requestInfo = multipartUpload(\n    ref.storage,\n    ref._location,\n    getMappings(),\n    new FbsBlob(data, true),\n    metadata\n  );\n  return ref.storage\n    .makeRequestWithTokens(requestInfo, newTextConnection)\n    .then(finalMetadata => {\n      return {\n        metadata: finalMetadata,\n        ref\n      };\n    });\n}\n\n/**\n * Uploads data to this object's location.\n * The upload can be paused and resumed, and exposes progress updates.\n * @public\n * @param ref - StorageReference where data should be uploaded.\n * @param data - The data to upload.\n * @param metadata - Metadata for the newly uploaded data.\n * @returns An UploadTask\n */\nexport function uploadBytesResumable(\n  ref: Reference,\n  data: Blob | Uint8Array | ArrayBuffer,\n  metadata?: Metadata\n): UploadTask {\n  ref._throwIfRoot('uploadBytesResumable');\n  return new UploadTask(ref, new FbsBlob(data), metadata);\n}\n\n/**\n * Uploads a string to this object's location.\n * The upload is not resumable.\n * @public\n * @param ref - StorageReference where string should be uploaded.\n * @param value - The string to upload.\n * @param format - The format of the string to upload.\n * @param metadata - Metadata for the newly uploaded string.\n * @returns A Promise containing an UploadResult\n */\nexport function uploadString(\n  ref: Reference,\n  value: string,\n  format: StringFormat = StringFormat.RAW,\n  metadata?: Metadata\n): Promise<UploadResult> {\n  ref._throwIfRoot('uploadString');\n  const data = dataFromString(format, value);\n  const metadataClone = { ...metadata } as Metadata;\n  if (metadataClone['contentType'] == null && data.contentType != null) {\n    metadataClone['contentType'] = data.contentType!;\n  }\n  return uploadBytes(ref, data.data, metadataClone);\n}\n\n/**\n * List all items (files) and prefixes (folders) under this storage reference.\n *\n * This is a helper method for calling list() repeatedly until there are\n * no more results. The default pagination size is 1000.\n *\n * Note: The results may not be consistent if objects are changed while this\n * operation is running.\n *\n * Warning: listAll may potentially consume too many resources if there are\n * too many results.\n * @public\n * @param ref - StorageReference to get list from.\n *\n * @returns A Promise that resolves with all the items and prefixes under\n *      the current storage reference. `prefixes` contains references to\n *      sub-directories and `items` contains references to objects in this\n *      folder. `nextPageToken` is never returned.\n */\nexport function listAll(ref: Reference): Promise<ListResult> {\n  const accumulator: ListResult = {\n    prefixes: [],\n    items: []\n  };\n  return listAllHelper(ref, accumulator).then(() => accumulator);\n}\n\n/**\n * Separated from listAll because async functions can't use \"arguments\".\n * @param ref\n * @param accumulator\n * @param pageToken\n */\nasync function listAllHelper(\n  ref: Reference,\n  accumulator: ListResult,\n  pageToken?: string\n): Promise<void> {\n  const opt: ListOptions = {\n    // maxResults is 1000 by default.\n    pageToken\n  };\n  const nextPage = await list(ref, opt);\n  accumulator.prefixes.push(...nextPage.prefixes);\n  accumulator.items.push(...nextPage.items);\n  if (nextPage.nextPageToken != null) {\n    await listAllHelper(ref, accumulator, nextPage.nextPageToken);\n  }\n}\n\n/**\n * List items (files) and prefixes (folders) under this storage reference.\n *\n * List API is only available for Firebase Rules Version 2.\n *\n * GCS is a key-blob store. Firebase Storage imposes the semantic of '/'\n * delimited folder structure.\n * Refer to GCS's List API if you want to learn more.\n *\n * To adhere to Firebase Rules's Semantics, Firebase Storage does not\n * support objects whose paths end with \"/\" or contain two consecutive\n * \"/\"s. Firebase Storage List API will filter these unsupported objects.\n * list() may fail if there are too many unsupported objects in the bucket.\n * @public\n *\n * @param ref - StorageReference to get list from.\n * @param options - See ListOptions for details.\n * @returns A Promise that resolves with the items and prefixes.\n *      `prefixes` contains references to sub-folders and `items`\n *      contains references to objects in this folder. `nextPageToken`\n *      can be used to get the rest of the results.\n */\nexport function list(\n  ref: Reference,\n  options?: ListOptions | null\n): Promise<ListResult> {\n  if (options != null) {\n    if (typeof options.maxResults === 'number') {\n      validateNumber(\n        'options.maxResults',\n        /* minValue= */ 1,\n        /* maxValue= */ 1000,\n        options.maxResults\n      );\n    }\n  }\n  const op = options || {};\n  const requestInfo = requestsList(\n    ref.storage,\n    ref._location,\n    /*delimiter= */ '/',\n    op.pageToken,\n    op.maxResults\n  );\n  return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection);\n}\n\n/**\n * A `Promise` that resolves with the metadata for this object. If this\n * object doesn't exist or metadata cannot be retrieved, the promise is\n * rejected.\n * @public\n * @param ref - StorageReference to get metadata from.\n */\nexport function getMetadata(ref: Reference): Promise<Metadata> {\n  ref._throwIfRoot('getMetadata');\n  const requestInfo = requestsGetMetadata(\n    ref.storage,\n    ref._location,\n    getMappings()\n  );\n  return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection);\n}\n\n/**\n * Updates the metadata for this object.\n * @public\n * @param ref - StorageReference to update metadata for.\n * @param metadata - The new metadata for the object.\n *     Only values that have been explicitly set will be changed. Explicitly\n *     setting a value to null will remove the metadata.\n * @returns A `Promise` that resolves\n *     with the new metadata for this object.\n *     See `firebaseStorage.Reference.prototype.getMetadata`\n */\nexport function updateMetadata(\n  ref: Reference,\n  metadata: Partial<Metadata>\n): Promise<Metadata> {\n  ref._throwIfRoot('updateMetadata');\n  const requestInfo = requestsUpdateMetadata(\n    ref.storage,\n    ref._location,\n    metadata,\n    getMappings()\n  );\n  return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection);\n}\n\n/**\n * Returns the download URL for the given Reference.\n * @public\n * @returns A `Promise` that resolves with the download\n *     URL for this object.\n */\nexport function getDownloadURL(ref: Reference): Promise<string> {\n  ref._throwIfRoot('getDownloadURL');\n  const requestInfo = requestsGetDownloadUrl(\n    ref.storage,\n    ref._location,\n    getMappings()\n  );\n  return ref.storage\n    .makeRequestWithTokens(requestInfo, newTextConnection)\n    .then(url => {\n      if (url === null) {\n        throw noDownloadURL();\n      }\n      return url;\n    });\n}\n\n/**\n * Deletes the object at this location.\n * @public\n * @param ref - StorageReference for object to delete.\n * @returns A `Promise` that resolves if the deletion succeeds.\n */\nexport function deleteObject(ref: Reference): Promise<void> {\n  ref._throwIfRoot('deleteObject');\n  const requestInfo = requestsDeleteObject(ref.storage, ref._location);\n  return ref.storage.makeRequestWithTokens(requestInfo, newTextConnection);\n}\n\n/**\n * Returns reference for object obtained by appending `childPath` to `ref`.\n *\n * @param ref - StorageReference to get child of.\n * @param childPath - Child path from provided ref.\n * @returns A reference to the object obtained by\n * appending childPath, removing any duplicate, beginning, or trailing\n * slashes.\n *\n */\nexport function _getChild(ref: Reference, childPath: string): Reference {\n  const newPath = child(ref._location.path, childPath);\n  const location = new Location(ref._location.bucket, newPath);\n  return new Reference(ref.storage, location);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Location } from './implementation/location';\nimport { FailRequest } from './implementation/failrequest';\nimport { Request, makeRequest } from './implementation/request';\nimport { RequestInfo } from './implementation/requestinfo';\nimport { Reference, _getChild } from './reference';\nimport { Provider } from '@firebase/component';\nimport { FirebaseAuthInternalName } from '@firebase/auth-interop-types';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  FirebaseApp,\n  FirebaseOptions,\n  _isFirebaseServerApp\n} from '@firebase/app';\nimport {\n  CONFIG_STORAGE_BUCKET_KEY,\n  DEFAULT_HOST,\n  DEFAULT_MAX_OPERATION_RETRY_TIME,\n  DEFAULT_MAX_UPLOAD_RETRY_TIME\n} from './implementation/constants';\nimport {\n  invalidArgument,\n  appDeleted,\n  noDefaultBucket\n} from './implementation/error';\nimport { validateNumber } from './implementation/type';\nimport { FirebaseStorage } from './public-types';\nimport {\n  createMockUserToken,\n  EmulatorMockTokenOptions,\n  isCloudWorkstation,\n  pingServer,\n  updateEmulatorBanner\n} from '@firebase/util';\nimport { Connection, ConnectionType } from './implementation/connection';\n\nexport function isUrl(path?: string): boolean {\n  return /^[A-Za-z]+:\\/\\//.test(path as string);\n}\n\n/**\n * Returns a firebaseStorage.Reference for the given url.\n */\nfunction refFromURL(service: FirebaseStorageImpl, url: string): Reference {\n  return new Reference(service, url);\n}\n\n/**\n * Returns a firebaseStorage.Reference for the given path in the default\n * bucket.\n */\nfunction refFromPath(\n  ref: FirebaseStorageImpl | Reference,\n  path?: string\n): Reference {\n  if (ref instanceof FirebaseStorageImpl) {\n    const service = ref;\n    if (service._bucket == null) {\n      throw noDefaultBucket();\n    }\n    const reference = new Reference(service, service._bucket!);\n    if (path != null) {\n      return refFromPath(reference, path);\n    } else {\n      return reference;\n    }\n  } else {\n    // ref is a Reference\n    if (path !== undefined) {\n      return _getChild(ref, path);\n    } else {\n      return ref;\n    }\n  }\n}\n\n/**\n * Returns a storage Reference for the given url.\n * @param storage - `Storage` instance.\n * @param url - URL. If empty, returns root reference.\n * @public\n */\nexport function ref(storage: FirebaseStorageImpl, url?: string): Reference;\n/**\n * Returns a storage Reference for the given path in the\n * default bucket.\n * @param storageOrRef - `Storage` service or storage `Reference`.\n * @param pathOrUrlStorage - path. If empty, returns root reference (if Storage\n * instance provided) or returns same reference (if Reference provided).\n * @public\n */\nexport function ref(\n  storageOrRef: FirebaseStorageImpl | Reference,\n  path?: string\n): Reference;\nexport function ref(\n  serviceOrRef: FirebaseStorageImpl | Reference,\n  pathOrUrl?: string\n): Reference | null {\n  if (pathOrUrl && isUrl(pathOrUrl)) {\n    if (serviceOrRef instanceof FirebaseStorageImpl) {\n      return refFromURL(serviceOrRef, pathOrUrl);\n    } else {\n      throw invalidArgument(\n        'To use ref(service, url), the first argument must be a Storage instance.'\n      );\n    }\n  } else {\n    return refFromPath(serviceOrRef, pathOrUrl);\n  }\n}\n\nfunction extractBucket(\n  host: string,\n  config?: FirebaseOptions\n): Location | null {\n  const bucketString = config?.[CONFIG_STORAGE_BUCKET_KEY];\n  if (bucketString == null) {\n    return null;\n  }\n  return Location.makeFromBucketSpec(bucketString, host);\n}\n\nexport function connectStorageEmulator(\n  storage: FirebaseStorageImpl,\n  host: string,\n  port: number,\n  options: {\n    mockUserToken?: EmulatorMockTokenOptions | string;\n  } = {}\n): void {\n  storage.host = `${host}:${port}`;\n  const useSsl = isCloudWorkstation(host);\n  // Workaround to get cookies in Firebase Studio\n  if (useSsl) {\n    void pingServer(`https://${storage.host}/b`);\n    updateEmulatorBanner('Storage', true);\n  }\n  storage._isUsingEmulator = true;\n  storage._protocol = useSsl ? 'https' : 'http';\n  const { mockUserToken } = options;\n  if (mockUserToken) {\n    storage._overrideAuthToken =\n      typeof mockUserToken === 'string'\n        ? mockUserToken\n        : createMockUserToken(mockUserToken, storage.app.options.projectId);\n  }\n}\n\n/**\n * A service that provides Firebase Storage Reference instances.\n * @param opt_url - gs:// url to a custom Storage Bucket\n *\n * @internal\n */\nexport class FirebaseStorageImpl implements FirebaseStorage {\n  _bucket: Location | null = null;\n  /**\n   * This string can be in the formats:\n   * - host\n   * - host:port\n   */\n  private _host: string = DEFAULT_HOST;\n  _protocol: string = 'https';\n  protected readonly _appId: string | null = null;\n  private readonly _requests: Set<Request<unknown>>;\n  private _deleted: boolean = false;\n  private _maxOperationRetryTime: number;\n  private _maxUploadRetryTime: number;\n  _overrideAuthToken?: string;\n\n  constructor(\n    /**\n     * FirebaseApp associated with this StorageService instance.\n     */\n    readonly app: FirebaseApp,\n    readonly _authProvider: Provider<FirebaseAuthInternalName>,\n    /**\n     * @internal\n     */\n    readonly _appCheckProvider: Provider<AppCheckInternalComponentName>,\n    /**\n     * @internal\n     */\n    readonly _url?: string,\n    readonly _firebaseVersion?: string,\n    public _isUsingEmulator = false\n  ) {\n    this._maxOperationRetryTime = DEFAULT_MAX_OPERATION_RETRY_TIME;\n    this._maxUploadRetryTime = DEFAULT_MAX_UPLOAD_RETRY_TIME;\n    this._requests = new Set();\n    if (_url != null) {\n      this._bucket = Location.makeFromBucketSpec(_url, this._host);\n    } else {\n      this._bucket = extractBucket(this._host, this.app.options);\n    }\n  }\n\n  /**\n   * The host string for this service, in the form of `host` or\n   * `host:port`.\n   */\n  get host(): string {\n    return this._host;\n  }\n\n  set host(host: string) {\n    this._host = host;\n    if (this._url != null) {\n      this._bucket = Location.makeFromBucketSpec(this._url, host);\n    } else {\n      this._bucket = extractBucket(host, this.app.options);\n    }\n  }\n\n  /**\n   * The maximum time to retry uploads in milliseconds.\n   */\n  get maxUploadRetryTime(): number {\n    return this._maxUploadRetryTime;\n  }\n\n  set maxUploadRetryTime(time: number) {\n    validateNumber(\n      'time',\n      /* minValue=*/ 0,\n      /* maxValue= */ Number.POSITIVE_INFINITY,\n      time\n    );\n    this._maxUploadRetryTime = time;\n  }\n\n  /**\n   * The maximum time to retry operations other than uploads or downloads in\n   * milliseconds.\n   */\n  get maxOperationRetryTime(): number {\n    return this._maxOperationRetryTime;\n  }\n\n  set maxOperationRetryTime(time: number) {\n    validateNumber(\n      'time',\n      /* minValue=*/ 0,\n      /* maxValue= */ Number.POSITIVE_INFINITY,\n      time\n    );\n    this._maxOperationRetryTime = time;\n  }\n\n  async _getAuthToken(): Promise<string | null> {\n    if (this._overrideAuthToken) {\n      return this._overrideAuthToken;\n    }\n    const auth = this._authProvider.getImmediate({ optional: true });\n    if (auth) {\n      const tokenData = await auth.getToken();\n      if (tokenData !== null) {\n        return tokenData.accessToken;\n      }\n    }\n    return null;\n  }\n\n  async _getAppCheckToken(): Promise<string | null> {\n    if (_isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {\n      return this.app.settings.appCheckToken;\n    }\n    const appCheck = this._appCheckProvider.getImmediate({ optional: true });\n    if (appCheck) {\n      const result = await appCheck.getToken();\n      // TODO: What do we want to do if there is an error getting the token?\n      // Context: appCheck.getToken() will never throw even if an error happened. In the error case, a dummy token will be\n      // returned along with an error field describing the error. In general, we shouldn't care about the error condition and just use\n      // the token (actual or dummy) to send requests.\n      return result.token;\n    }\n    return null;\n  }\n\n  /**\n   * Stop running requests and prevent more from being created.\n   */\n  _delete(): Promise<void> {\n    if (!this._deleted) {\n      this._deleted = true;\n      this._requests.forEach(request => request.cancel());\n      this._requests.clear();\n    }\n    return Promise.resolve();\n  }\n\n  /**\n   * Returns a new firebaseStorage.Reference object referencing this StorageService\n   * at the given Location.\n   */\n  _makeStorageReference(loc: Location): Reference {\n    return new Reference(this, loc);\n  }\n\n  /**\n   * @param requestInfo - HTTP RequestInfo object\n   * @param authToken - Firebase auth token\n   */\n  _makeRequest<I extends ConnectionType, O>(\n    requestInfo: RequestInfo<I, O>,\n    requestFactory: () => Connection<I>,\n    authToken: string | null,\n    appCheckToken: string | null,\n    retry = true\n  ): Request<O> {\n    if (!this._deleted) {\n      const request = makeRequest(\n        requestInfo,\n        this._appId,\n        authToken,\n        appCheckToken,\n        requestFactory,\n        this._firebaseVersion,\n        retry,\n        this._isUsingEmulator\n      );\n      this._requests.add(request);\n      // Request removes itself from set when complete.\n      request.getPromise().then(\n        () => this._requests.delete(request),\n        () => this._requests.delete(request)\n      );\n      return request;\n    } else {\n      return new FailRequest(appDeleted());\n    }\n  }\n\n  async makeRequestWithTokens<I extends ConnectionType, O>(\n    requestInfo: RequestInfo<I, O>,\n    requestFactory: () => Connection<I>\n  ): Promise<O> {\n    const [authToken, appCheckToken] = await Promise.all([\n      this._getAuthToken(),\n      this._getAppCheckToken()\n    ]);\n\n    return this._makeRequest(\n      requestInfo,\n      requestFactory,\n      authToken,\n      appCheckToken\n    ).getPromise();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Type constant for Firebase Storage.\n */\nexport const STORAGE_TYPE = 'storage';\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { _getProvider, FirebaseApp, getApp } from '@firebase/app';\n\nimport {\n  ref as refInternal,\n  FirebaseStorageImpl,\n  connectStorageEmulator as connectEmulatorInternal\n} from './service';\nimport { Provider } from '@firebase/component';\n\nimport {\n  StorageReference,\n  FirebaseStorage,\n  UploadResult,\n  ListOptions,\n  ListResult,\n  UploadTask,\n  SettableMetadata,\n  UploadMetadata,\n  FullMetadata\n} from './public-types';\nimport { Metadata as MetadataInternal } from './metadata';\nimport {\n  uploadBytes as uploadBytesInternal,\n  uploadBytesResumable as uploadBytesResumableInternal,\n  uploadString as uploadStringInternal,\n  getMetadata as getMetadataInternal,\n  updateMetadata as updateMetadataInternal,\n  list as listInternal,\n  listAll as listAllInternal,\n  getDownloadURL as getDownloadURLInternal,\n  deleteObject as deleteObjectInternal,\n  Reference,\n  _getChild as _getChildInternal,\n  getBytesInternal\n} from './reference';\nimport { STORAGE_TYPE } from './constants';\nimport {\n  EmulatorMockTokenOptions,\n  getModularInstance,\n  getDefaultEmulatorHostnameAndPort\n} from '@firebase/util';\nimport { StringFormat } from './implementation/string';\n\nexport { EmulatorMockTokenOptions } from '@firebase/util';\n\nexport { StorageError, StorageErrorCode } from './implementation/error';\n\n/**\n * Public types.\n */\nexport * from './public-types';\n\nexport { Location as _Location } from './implementation/location';\nexport { UploadTask as _UploadTask } from './task';\nexport type { Reference as _Reference } from './reference';\nexport type { FirebaseStorageImpl as _FirebaseStorageImpl } from './service';\nexport { FbsBlob as _FbsBlob } from './implementation/blob';\nexport { dataFromString as _dataFromString } from './implementation/string';\nexport {\n  invalidRootOperation as _invalidRootOperation,\n  invalidArgument as _invalidArgument\n} from './implementation/error';\nexport {\n  TaskEvent as _TaskEvent,\n  TaskState as _TaskState\n} from './implementation/taskenums';\nexport { StringFormat };\n\n/**\n * Downloads the data at the object's location. Returns an error if the object\n * is not found.\n *\n * To use this functionality, you have to whitelist your app's origin in your\n * Cloud Storage bucket. See also\n * https://cloud.google.com/storage/docs/configuring-cors\n *\n * @public\n * @param ref - StorageReference where data should be downloaded.\n * @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to\n * retrieve.\n * @returns A Promise containing the object's bytes\n */\nexport function getBytes(\n  ref: StorageReference,\n  maxDownloadSizeBytes?: number\n): Promise<ArrayBuffer> {\n  ref = getModularInstance(ref);\n  return getBytesInternal(ref as Reference, maxDownloadSizeBytes);\n}\n\n/**\n * Uploads data to this object's location.\n * The upload is not resumable.\n * @public\n * @param ref - {@link StorageReference} where data should be uploaded.\n * @param data - The data to upload.\n * @param metadata - Metadata for the data to upload.\n * @returns A Promise containing an UploadResult\n */\nexport function uploadBytes(\n  ref: StorageReference,\n  data: Blob | Uint8Array | ArrayBuffer,\n  metadata?: UploadMetadata\n): Promise<UploadResult> {\n  ref = getModularInstance(ref);\n  return uploadBytesInternal(\n    ref as Reference,\n    data,\n    metadata as MetadataInternal\n  );\n}\n\n/**\n * Uploads a string to this object's location.\n * The upload is not resumable.\n * @public\n * @param ref - {@link StorageReference} where string should be uploaded.\n * @param value - The string to upload.\n * @param format - The format of the string to upload.\n * @param metadata - Metadata for the string to upload.\n * @returns A Promise containing an UploadResult\n */\nexport function uploadString(\n  ref: StorageReference,\n  value: string,\n  format?: StringFormat,\n  metadata?: UploadMetadata\n): Promise<UploadResult> {\n  ref = getModularInstance(ref);\n  return uploadStringInternal(\n    ref as Reference,\n    value,\n    format,\n    metadata as MetadataInternal\n  );\n}\n\n/**\n * Uploads data to this object's location.\n * The upload can be paused and resumed, and exposes progress updates.\n * @public\n * @param ref - {@link StorageReference} where data should be uploaded.\n * @param data - The data to upload.\n * @param metadata - Metadata for the data to upload.\n * @returns An UploadTask\n */\nexport function uploadBytesResumable(\n  ref: StorageReference,\n  data: Blob | Uint8Array | ArrayBuffer,\n  metadata?: UploadMetadata\n): UploadTask {\n  ref = getModularInstance(ref);\n  return uploadBytesResumableInternal(\n    ref as Reference,\n    data,\n    metadata as MetadataInternal\n  ) as UploadTask;\n}\n\n/**\n * A `Promise` that resolves with the metadata for this object. If this\n * object doesn't exist or metadata cannot be retrieved, the promise is\n * rejected.\n * @public\n * @param ref - {@link StorageReference} to get metadata from.\n */\nexport function getMetadata(ref: StorageReference): Promise<FullMetadata> {\n  ref = getModularInstance(ref);\n  return getMetadataInternal(ref as Reference) as Promise<FullMetadata>;\n}\n\n/**\n * Updates the metadata for this object.\n * @public\n * @param ref - {@link StorageReference} to update metadata for.\n * @param metadata - The new metadata for the object.\n *     Only values that have been explicitly set will be changed. Explicitly\n *     setting a value to null will remove the metadata.\n * @returns A `Promise` that resolves with the new metadata for this object.\n */\nexport function updateMetadata(\n  ref: StorageReference,\n  metadata: SettableMetadata\n): Promise<FullMetadata> {\n  ref = getModularInstance(ref);\n  return updateMetadataInternal(\n    ref as Reference,\n    metadata as Partial<MetadataInternal>\n  ) as Promise<FullMetadata>;\n}\n\n/**\n * List items (files) and prefixes (folders) under this storage reference.\n *\n * List API is only available for Firebase Rules Version 2.\n *\n * GCS is a key-blob store. Firebase Storage imposes the semantic of '/'\n * delimited folder structure.\n * Refer to GCS's List API if you want to learn more.\n *\n * To adhere to Firebase Rules's Semantics, Firebase Storage does not\n * support objects whose paths end with \"/\" or contain two consecutive\n * \"/\"s. Firebase Storage List API will filter these unsupported objects.\n * list() may fail if there are too many unsupported objects in the bucket.\n * @public\n *\n * @param ref - {@link StorageReference} to get list from.\n * @param options - See {@link ListOptions} for details.\n * @returns A `Promise` that resolves with the items and prefixes.\n *      `prefixes` contains references to sub-folders and `items`\n *      contains references to objects in this folder. `nextPageToken`\n *      can be used to get the rest of the results.\n */\nexport function list(\n  ref: StorageReference,\n  options?: ListOptions\n): Promise<ListResult> {\n  ref = getModularInstance(ref);\n  return listInternal(ref as Reference, options);\n}\n\n/**\n * List all items (files) and prefixes (folders) under this storage reference.\n *\n * This is a helper method for calling list() repeatedly until there are\n * no more results. The default pagination size is 1000.\n *\n * Note: The results may not be consistent if objects are changed while this\n * operation is running.\n *\n * Warning: `listAll` may potentially consume too many resources if there are\n * too many results.\n * @public\n * @param ref - {@link StorageReference} to get list from.\n *\n * @returns A `Promise` that resolves with all the items and prefixes under\n *      the current storage reference. `prefixes` contains references to\n *      sub-directories and `items` contains references to objects in this\n *      folder. `nextPageToken` is never returned.\n */\nexport function listAll(ref: StorageReference): Promise<ListResult> {\n  ref = getModularInstance(ref);\n  return listAllInternal(ref as Reference);\n}\n\n/**\n * Returns the download URL for the given {@link StorageReference}.\n * @public\n * @param ref - {@link StorageReference} to get the download URL for.\n * @returns A `Promise` that resolves with the download\n *     URL for this object.\n */\nexport function getDownloadURL(ref: StorageReference): Promise<string> {\n  ref = getModularInstance(ref);\n  return getDownloadURLInternal(ref as Reference);\n}\n\n/**\n * Deletes the object at this location.\n * @public\n * @param ref - {@link StorageReference} for object to delete.\n * @returns A `Promise` that resolves if the deletion succeeds.\n */\nexport function deleteObject(ref: StorageReference): Promise<void> {\n  ref = getModularInstance(ref);\n  return deleteObjectInternal(ref as Reference);\n}\n\n/**\n * Returns a {@link StorageReference} for the given url.\n * @param storage - {@link FirebaseStorage} instance.\n * @param url - URL. If empty, returns root reference.\n * @public\n */\nexport function ref(storage: FirebaseStorage, url?: string): StorageReference;\n/**\n * Returns a {@link StorageReference} for the given path in the\n * default bucket.\n * @param storageOrRef - {@link FirebaseStorage} or {@link StorageReference}.\n * @param pathOrUrlStorage - path. If empty, returns root reference (if {@link FirebaseStorage}\n * instance provided) or returns same reference (if {@link StorageReference} provided).\n * @public\n */\nexport function ref(\n  storageOrRef: FirebaseStorage | StorageReference,\n  path?: string\n): StorageReference;\nexport function ref(\n  serviceOrRef: FirebaseStorage | StorageReference,\n  pathOrUrl?: string\n): StorageReference | null {\n  serviceOrRef = getModularInstance(serviceOrRef);\n  return refInternal(\n    serviceOrRef as FirebaseStorageImpl | Reference,\n    pathOrUrl\n  );\n}\n\n/**\n * @internal\n */\nexport function _getChild(ref: StorageReference, childPath: string): Reference {\n  return _getChildInternal(ref as Reference, childPath);\n}\n\n/**\n * Gets a {@link FirebaseStorage} instance for the given Firebase app.\n * @public\n * @param app - Firebase app to get {@link FirebaseStorage} instance for.\n * @param bucketUrl - The gs:// url to your Firebase Storage Bucket.\n * If not passed, uses the app's default Storage Bucket.\n * @returns A {@link FirebaseStorage} instance.\n */\nexport function getStorage(\n  app: FirebaseApp = getApp(),\n  bucketUrl?: string\n): FirebaseStorage {\n  app = getModularInstance(app);\n  const storageProvider: Provider<'storage'> = _getProvider(app, STORAGE_TYPE);\n  const storageInstance = storageProvider.getImmediate({\n    identifier: bucketUrl\n  });\n  const emulator = getDefaultEmulatorHostnameAndPort('storage');\n  if (emulator) {\n    connectStorageEmulator(storageInstance, ...emulator);\n  }\n  return storageInstance;\n}\n\n/**\n * Modify this {@link FirebaseStorage} instance to communicate with the Cloud Storage emulator.\n *\n * @param storage - The {@link FirebaseStorage} instance\n * @param host - The emulator host (ex: localhost)\n * @param port - The emulator port (ex: 5001)\n * @param options - Emulator options. `options.mockUserToken` is the mock auth\n * token to use for unit testing Security Rules.\n * @public\n */\nexport function connectStorageEmulator(\n  storage: FirebaseStorage,\n  host: string,\n  port: number,\n  options: {\n    mockUserToken?: EmulatorMockTokenOptions | string;\n  } = {}\n): void {\n  connectEmulatorInternal(storage as FirebaseStorageImpl, host, port, options);\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { StorageReference } from './public-types';\nimport { Reference, getStreamInternal } from './reference';\nimport { getModularInstance } from '@firebase/util';\n\n/**\n * Downloads the data at the object's location. Returns an error if the object\n * is not found.\n *\n * To use this functionality, you have to whitelist your app's origin in your\n * Cloud Storage bucket. See also\n * https://cloud.google.com/storage/docs/configuring-cors\n *\n * This API is not available in Node.\n *\n * @public\n * @param ref - StorageReference where data should be downloaded.\n * @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to\n * retrieve.\n * @returns A Promise that resolves with a Blob containing the object's bytes\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function getBlob(\n  ref: StorageReference,\n  maxDownloadSizeBytes?: number\n): Promise<Blob> {\n  throw new Error('getBlob() is only available in Browser-like environments');\n}\n\n/**\n * Downloads the data at the object's location. Raises an error event if the\n * object is not found.\n *\n * This API is only available in Node.\n *\n * @public\n * @param ref - StorageReference where data should be downloaded.\n * @param maxDownloadSizeBytes - If set, the maximum allowed size in bytes to\n * retrieve.\n * @returns A stream with the object's data as bytes\n */\nexport function getStream(\n  ref: StorageReference,\n  maxDownloadSizeBytes?: number\n): ReadableStream {\n  ref = getModularInstance(ref);\n  return getStreamInternal(ref as Reference, maxDownloadSizeBytes);\n}\n", "/**\n * Cloud Storage for Firebase\n *\n * @packageDocumentation\n */\n\n/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  _registerComponent,\n  registerVersion,\n  SDK_VERSION\n} from '@firebase/app';\n\nimport { FirebaseStorageImpl } from './service';\nimport {\n  Component,\n  ComponentType,\n  ComponentContainer,\n  InstanceFactoryOptions\n} from '@firebase/component';\n\nimport { name, version } from '../package.json';\n\nimport { FirebaseStorage } from './public-types';\nimport { STORAGE_TYPE } from './constants';\n\nexport * from './api';\nexport * from './api.node';\n\nfunction factory(\n  container: ComponentContainer,\n  { instanceIdentifier: url }: InstanceFactoryOptions\n): FirebaseStorage {\n  const app = container.getProvider('app').getImmediate();\n  const authProvider = container.getProvider('auth-internal');\n  const appCheckProvider = container.getProvider('app-check-internal');\n\n  return new FirebaseStorageImpl(\n    app,\n    authProvider,\n    appCheckProvider,\n    url,\n    SDK_VERSION\n  );\n}\n\nfunction registerStorage(): void {\n  _registerComponent(\n    new Component(\n      STORAGE_TYPE,\n      factory,\n      ComponentType.PUBLIC\n    ).setMultipleInstances(true)\n  );\n\n  registerVersion(name, version);\n}\n\nregisterStorage();\n", "export * from '@firebase/storage';\n//# sourceMappingURL=index.mjs.map\n", "/**\n * Firebase Configuration for Obsidian Plugin\n */\n\nimport { initializeApp } from 'firebase/app';\nimport { getAuth } from 'firebase/auth';\nimport { getFunctions } from 'firebase/functions';\nimport { getStorage } from 'firebase/storage';\n\nconst firebaseConfig = {\n  apiKey: \"AIzaSyD_qH-0Gr_pdmNLOQW5pea2BbiyHpxstN8\",\n  authDomain: \"uuu-gl.firebaseapp.com\",\n  projectId: \"uuu-gl\",\n  storageBucket: \"uuu-gl.firebasestorage.app\",\n  messagingSenderId: \"484571716021\",\n  appId: \"1:484571716021:web:25ca37bf90f320cf07a1fc\"\n};\n\nexport const app = initializeApp(firebaseConfig);\nexport const auth = getAuth(app);\nexport const functions = getFunctions(app, 'us-central1');\nexport const storage = getStorage(app);\n", "/**\n * FingerprintJS v5.0.1 - Copyright (c) FingerprintJS, Inc, 2025 (https://fingerprint.com)\n *\n * Licensed under MIT License\n *\n * Copyright (c) 2025 FingerprintJS, Inc\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar version = \"5.0.1\";\n\nfunction wait(durationMs, resolveWith) {\n    return new Promise((resolve) => setTimeout(resolve, durationMs, resolveWith));\n}\n/**\n * Allows asynchronous actions and microtasks to happen.\n */\nfunction releaseEventLoop() {\n    // Don't use setTimeout because Chrome throttles it in some cases causing very long agent execution:\n    // https://stackoverflow.com/a/6032591/1118709\n    // https://github.com/chromium/chromium/commit/0295dd09496330f3a9103ef7e543fa9b6050409b\n    // Reusing a MessageChannel object gives no noticeable benefits\n    return new Promise((resolve) => {\n        const channel = new MessageChannel();\n        channel.port1.onmessage = () => resolve();\n        channel.port2.postMessage(null);\n    });\n}\nfunction requestIdleCallbackIfAvailable(fallbackTimeout, deadlineTimeout = Infinity) {\n    const { requestIdleCallback } = window;\n    if (requestIdleCallback) {\n        // The function `requestIdleCallback` loses the binding to `window` here.\n        // `globalThis` isn't always equal `window` (see https://github.com/fingerprintjs/fingerprintjs/issues/683).\n        // Therefore, an error can occur. `call(window,` prevents the error.\n        return new Promise((resolve) => requestIdleCallback.call(window, () => resolve(), { timeout: deadlineTimeout }));\n    }\n    else {\n        return wait(Math.min(fallbackTimeout, deadlineTimeout));\n    }\n}\nfunction isPromise(value) {\n    return !!value && typeof value.then === 'function';\n}\n/**\n * Calls a maybe asynchronous function without creating microtasks when the function is synchronous.\n * Catches errors in both cases.\n *\n * If just you run a code like this:\n * ```\n * console.time('Action duration')\n * await action()\n * console.timeEnd('Action duration')\n * ```\n * The synchronous function time can be measured incorrectly because another microtask may run before the `await`\n * returns the control back to the code.\n */\nfunction awaitIfAsync(action, callback) {\n    try {\n        const returnedValue = action();\n        if (isPromise(returnedValue)) {\n            returnedValue.then((result) => callback(true, result), (error) => callback(false, error));\n        }\n        else {\n            callback(true, returnedValue);\n        }\n    }\n    catch (error) {\n        callback(false, error);\n    }\n}\n/**\n * If you run many synchronous tasks without using this function, the JS main loop will be busy and asynchronous tasks\n * (e.g. completing a network request, rendering the page) won't be able to happen.\n * This function allows running many synchronous tasks such way that asynchronous tasks can run too in background.\n */\nasync function mapWithBreaks(items, callback, loopReleaseInterval = 16) {\n    const results = Array(items.length);\n    let lastLoopReleaseTime = Date.now();\n    for (let i = 0; i < items.length; ++i) {\n        results[i] = callback(items[i], i);\n        const now = Date.now();\n        if (now >= lastLoopReleaseTime + loopReleaseInterval) {\n            lastLoopReleaseTime = now;\n            await releaseEventLoop();\n        }\n    }\n    return results;\n}\n/**\n * Makes the given promise never emit an unhandled promise rejection console warning.\n * The promise will still pass errors to the next promises.\n * Returns the input promise for convenience.\n *\n * Otherwise, promise emits a console warning unless it has a `catch` listener.\n */\nfunction suppressUnhandledRejectionWarning(promise) {\n    promise.then(undefined, () => undefined);\n    return promise;\n}\n\n/*\n * This file contains functions to work with pure data only (no browser features, DOM, side effects, etc).\n */\n/**\n * Does the same as Array.prototype.includes but has better typing\n */\nfunction includes(haystack, needle) {\n    for (let i = 0, l = haystack.length; i < l; ++i) {\n        if (haystack[i] === needle) {\n            return true;\n        }\n    }\n    return false;\n}\n/**\n * Like `!includes()` but with proper typing\n */\nfunction excludes(haystack, needle) {\n    return !includes(haystack, needle);\n}\n/**\n * Be careful, NaN can return\n */\nfunction toInt(value) {\n    return parseInt(value);\n}\n/**\n * Be careful, NaN can return\n */\nfunction toFloat(value) {\n    return parseFloat(value);\n}\nfunction replaceNaN(value, replacement) {\n    return typeof value === 'number' && isNaN(value) ? replacement : value;\n}\nfunction countTruthy(values) {\n    return values.reduce((sum, value) => sum + (value ? 1 : 0), 0);\n}\nfunction round(value, base = 1) {\n    if (Math.abs(base) >= 1) {\n        return Math.round(value / base) * base;\n    }\n    else {\n        // Sometimes when a number is multiplied by a small number, precision is lost,\n        // for example 1234 * 0.0001 === 0.12340000000000001, and it's more precise divide: 1234 / (1 / 0.0001) === 0.1234.\n        const counterBase = 1 / base;\n        return Math.round(value * counterBase) / counterBase;\n    }\n}\n/**\n * Parses a CSS selector into tag name with HTML attributes.\n * Only single element selector are supported (without operators like space, +, >, etc).\n *\n * Multiple values can be returned for each attribute. You decide how to handle them.\n */\nfunction parseSimpleCssSelector(selector) {\n    var _a, _b;\n    const errorMessage = `Unexpected syntax '${selector}'`;\n    const tagMatch = /^\\s*([a-z-]*)(.*)$/i.exec(selector);\n    const tag = tagMatch[1] || undefined;\n    const attributes = {};\n    const partsRegex = /([.:#][\\w-]+|\\[.+?\\])/gi;\n    const addAttribute = (name, value) => {\n        attributes[name] = attributes[name] || [];\n        attributes[name].push(value);\n    };\n    for (;;) {\n        const match = partsRegex.exec(tagMatch[2]);\n        if (!match) {\n            break;\n        }\n        const part = match[0];\n        switch (part[0]) {\n            case '.':\n                addAttribute('class', part.slice(1));\n                break;\n            case '#':\n                addAttribute('id', part.slice(1));\n                break;\n            case '[': {\n                const attributeMatch = /^\\[([\\w-]+)([~|^$*]?=(\"(.*?)\"|([\\w-]+)))?(\\s+[is])?\\]$/.exec(part);\n                if (attributeMatch) {\n                    addAttribute(attributeMatch[1], (_b = (_a = attributeMatch[4]) !== null && _a !== void 0 ? _a : attributeMatch[5]) !== null && _b !== void 0 ? _b : '');\n                }\n                else {\n                    throw new Error(errorMessage);\n                }\n                break;\n            }\n            default:\n                throw new Error(errorMessage);\n        }\n    }\n    return [tag, attributes];\n}\n/**\n * Converts a string to UTF8 bytes\n */\nfunction getUTF8Bytes(input) {\n    // Benchmark: https://jsbench.me/b6klaaxgwq/1\n    // If you want to just count bytes, see solutions at https://jsbench.me/ehklab415e/1\n    const result = new Uint8Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n        // `charCode` is faster than encoding, so we prefer that when it's possible\n        const charCode = input.charCodeAt(i);\n        // In case of non-ASCII symbols we use proper encoding\n        if (charCode > 127) {\n            return new TextEncoder().encode(input);\n        }\n        result[i] = charCode;\n    }\n    return result;\n}\n\n/*\n * Based on https://github.com/karanlyons/murmurHash3.js/blob/a33d0723127e2e5415056c455f8aed2451ace208/murmurHash3.js\n */\n/**\n * Adds two 64-bit values (provided as tuples of 32-bit values)\n * and updates (mutates) first value to write the result\n */\nfunction x64Add(m, n) {\n    const m0 = m[0] >>> 16, m1 = m[0] & 0xffff, m2 = m[1] >>> 16, m3 = m[1] & 0xffff;\n    const n0 = n[0] >>> 16, n1 = n[0] & 0xffff, n2 = n[1] >>> 16, n3 = n[1] & 0xffff;\n    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;\n    o3 += m3 + n3;\n    o2 += o3 >>> 16;\n    o3 &= 0xffff;\n    o2 += m2 + n2;\n    o1 += o2 >>> 16;\n    o2 &= 0xffff;\n    o1 += m1 + n1;\n    o0 += o1 >>> 16;\n    o1 &= 0xffff;\n    o0 += m0 + n0;\n    o0 &= 0xffff;\n    m[0] = (o0 << 16) | o1;\n    m[1] = (o2 << 16) | o3;\n}\n/**\n * Multiplies two 64-bit values (provided as tuples of 32-bit values)\n * and updates (mutates) first value to write the result\n */\nfunction x64Multiply(m, n) {\n    const m0 = m[0] >>> 16, m1 = m[0] & 0xffff, m2 = m[1] >>> 16, m3 = m[1] & 0xffff;\n    const n0 = n[0] >>> 16, n1 = n[0] & 0xffff, n2 = n[1] >>> 16, n3 = n[1] & 0xffff;\n    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;\n    o3 += m3 * n3;\n    o2 += o3 >>> 16;\n    o3 &= 0xffff;\n    o2 += m2 * n3;\n    o1 += o2 >>> 16;\n    o2 &= 0xffff;\n    o2 += m3 * n2;\n    o1 += o2 >>> 16;\n    o2 &= 0xffff;\n    o1 += m1 * n3;\n    o0 += o1 >>> 16;\n    o1 &= 0xffff;\n    o1 += m2 * n2;\n    o0 += o1 >>> 16;\n    o1 &= 0xffff;\n    o1 += m3 * n1;\n    o0 += o1 >>> 16;\n    o1 &= 0xffff;\n    o0 += m0 * n3 + m1 * n2 + m2 * n1 + m3 * n0;\n    o0 &= 0xffff;\n    m[0] = (o0 << 16) | o1;\n    m[1] = (o2 << 16) | o3;\n}\n/**\n * Provides left rotation of the given int64 value (provided as tuple of two int32)\n * by given number of bits. Result is written back to the value\n */\nfunction x64Rotl(m, bits) {\n    const m0 = m[0];\n    bits %= 64;\n    if (bits === 32) {\n        m[0] = m[1];\n        m[1] = m0;\n    }\n    else if (bits < 32) {\n        m[0] = (m0 << bits) | (m[1] >>> (32 - bits));\n        m[1] = (m[1] << bits) | (m0 >>> (32 - bits));\n    }\n    else {\n        bits -= 32;\n        m[0] = (m[1] << bits) | (m0 >>> (32 - bits));\n        m[1] = (m0 << bits) | (m[1] >>> (32 - bits));\n    }\n}\n/**\n * Provides a left shift of the given int32 value (provided as tuple of [0, int32])\n * by given number of bits. Result is written back to the value\n */\nfunction x64LeftShift(m, bits) {\n    bits %= 64;\n    if (bits === 0) {\n        return;\n    }\n    else if (bits < 32) {\n        m[0] = m[1] >>> (32 - bits);\n        m[1] = m[1] << bits;\n    }\n    else {\n        m[0] = m[1] << (bits - 32);\n        m[1] = 0;\n    }\n}\n/**\n * Provides a XOR of the given int64 values(provided as tuple of two int32).\n * Result is written back to the first value\n */\nfunction x64Xor(m, n) {\n    m[0] ^= n[0];\n    m[1] ^= n[1];\n}\nconst F1 = [0xff51afd7, 0xed558ccd];\nconst F2 = [0xc4ceb9fe, 0x1a85ec53];\n/**\n * Calculates murmurHash3's final x64 mix of that block and writes result back to the input value.\n * (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the\n * only place where we need to right shift 64bit ints.)\n */\nfunction x64Fmix(h) {\n    const shifted = [0, h[0] >>> 1];\n    x64Xor(h, shifted);\n    x64Multiply(h, F1);\n    shifted[1] = h[0] >>> 1;\n    x64Xor(h, shifted);\n    x64Multiply(h, F2);\n    shifted[1] = h[0] >>> 1;\n    x64Xor(h, shifted);\n}\nconst C1 = [0x87c37b91, 0x114253d5];\nconst C2 = [0x4cf5ad43, 0x2745937f];\nconst M$1 = [0, 5];\nconst N1 = [0, 0x52dce729];\nconst N2 = [0, 0x38495ab5];\n/**\n * Given a string and an optional seed as an int, returns a 128 bit\n * hash using the x64 flavor of MurmurHash3, as an unsigned hex.\n * All internal functions mutates passed value to achieve minimal memory allocations and GC load\n *\n * Benchmark https://jsbench.me/p4lkpaoabi/1\n */\nfunction x64hash128(input, seed) {\n    const key = getUTF8Bytes(input);\n    seed = seed || 0;\n    const length = [0, key.length];\n    const remainder = length[1] % 16;\n    const bytes = length[1] - remainder;\n    const h1 = [0, seed];\n    const h2 = [0, seed];\n    const k1 = [0, 0];\n    const k2 = [0, 0];\n    let i;\n    for (i = 0; i < bytes; i = i + 16) {\n        k1[0] = key[i + 4] | (key[i + 5] << 8) | (key[i + 6] << 16) | (key[i + 7] << 24);\n        k1[1] = key[i] | (key[i + 1] << 8) | (key[i + 2] << 16) | (key[i + 3] << 24);\n        k2[0] = key[i + 12] | (key[i + 13] << 8) | (key[i + 14] << 16) | (key[i + 15] << 24);\n        k2[1] = key[i + 8] | (key[i + 9] << 8) | (key[i + 10] << 16) | (key[i + 11] << 24);\n        x64Multiply(k1, C1);\n        x64Rotl(k1, 31);\n        x64Multiply(k1, C2);\n        x64Xor(h1, k1);\n        x64Rotl(h1, 27);\n        x64Add(h1, h2);\n        x64Multiply(h1, M$1);\n        x64Add(h1, N1);\n        x64Multiply(k2, C2);\n        x64Rotl(k2, 33);\n        x64Multiply(k2, C1);\n        x64Xor(h2, k2);\n        x64Rotl(h2, 31);\n        x64Add(h2, h1);\n        x64Multiply(h2, M$1);\n        x64Add(h2, N2);\n    }\n    k1[0] = 0;\n    k1[1] = 0;\n    k2[0] = 0;\n    k2[1] = 0;\n    const val = [0, 0];\n    switch (remainder) {\n        case 15:\n            val[1] = key[i + 14];\n            x64LeftShift(val, 48);\n            x64Xor(k2, val);\n        // fallthrough\n        case 14:\n            val[1] = key[i + 13];\n            x64LeftShift(val, 40);\n            x64Xor(k2, val);\n        // fallthrough\n        case 13:\n            val[1] = key[i + 12];\n            x64LeftShift(val, 32);\n            x64Xor(k2, val);\n        // fallthrough\n        case 12:\n            val[1] = key[i + 11];\n            x64LeftShift(val, 24);\n            x64Xor(k2, val);\n        // fallthrough\n        case 11:\n            val[1] = key[i + 10];\n            x64LeftShift(val, 16);\n            x64Xor(k2, val);\n        // fallthrough\n        case 10:\n            val[1] = key[i + 9];\n            x64LeftShift(val, 8);\n            x64Xor(k2, val);\n        // fallthrough\n        case 9:\n            val[1] = key[i + 8];\n            x64Xor(k2, val);\n            x64Multiply(k2, C2);\n            x64Rotl(k2, 33);\n            x64Multiply(k2, C1);\n            x64Xor(h2, k2);\n        // fallthrough\n        case 8:\n            val[1] = key[i + 7];\n            x64LeftShift(val, 56);\n            x64Xor(k1, val);\n        // fallthrough\n        case 7:\n            val[1] = key[i + 6];\n            x64LeftShift(val, 48);\n            x64Xor(k1, val);\n        // fallthrough\n        case 6:\n            val[1] = key[i + 5];\n            x64LeftShift(val, 40);\n            x64Xor(k1, val);\n        // fallthrough\n        case 5:\n            val[1] = key[i + 4];\n            x64LeftShift(val, 32);\n            x64Xor(k1, val);\n        // fallthrough\n        case 4:\n            val[1] = key[i + 3];\n            x64LeftShift(val, 24);\n            x64Xor(k1, val);\n        // fallthrough\n        case 3:\n            val[1] = key[i + 2];\n            x64LeftShift(val, 16);\n            x64Xor(k1, val);\n        // fallthrough\n        case 2:\n            val[1] = key[i + 1];\n            x64LeftShift(val, 8);\n            x64Xor(k1, val);\n        // fallthrough\n        case 1:\n            val[1] = key[i];\n            x64Xor(k1, val);\n            x64Multiply(k1, C1);\n            x64Rotl(k1, 31);\n            x64Multiply(k1, C2);\n            x64Xor(h1, k1);\n        // fallthrough\n    }\n    x64Xor(h1, length);\n    x64Xor(h2, length);\n    x64Add(h1, h2);\n    x64Add(h2, h1);\n    x64Fmix(h1);\n    x64Fmix(h2);\n    x64Add(h1, h2);\n    x64Add(h2, h1);\n    return (('00000000' + (h1[0] >>> 0).toString(16)).slice(-8) +\n        ('00000000' + (h1[1] >>> 0).toString(16)).slice(-8) +\n        ('00000000' + (h2[0] >>> 0).toString(16)).slice(-8) +\n        ('00000000' + (h2[1] >>> 0).toString(16)).slice(-8));\n}\n\n/**\n * Converts an error object to a plain object that can be used with `JSON.stringify`.\n * If you just run `JSON.stringify(error)`, you'll get `'{}'`.\n */\nfunction errorToObject(error) {\n    var _a;\n    return {\n        name: error.name,\n        message: error.message,\n        stack: (_a = error.stack) === null || _a === void 0 ? void 0 : _a.split('\\n'),\n        // The fields are not enumerable, so TS is wrong saying that they will be overridden\n        ...error,\n    };\n}\nfunction isFunctionNative(func) {\n    return /^function\\s.*?\\{\\s*\\[native code]\\s*}$/.test(String(func));\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nfunction isFinalResultLoaded(loadResult) {\n    return typeof loadResult !== 'function';\n}\n/**\n * Loads the given entropy source. Returns a function that gets an entropy component from the source.\n *\n * The result is returned synchronously to prevent `loadSources` from\n * waiting for one source to load before getting the components from the other sources.\n */\nfunction loadSource(source, sourceOptions) {\n    const sourceLoadPromise = suppressUnhandledRejectionWarning(new Promise((resolveLoad) => {\n        const loadStartTime = Date.now();\n        // `awaitIfAsync` is used instead of just `await` in order to measure the duration of synchronous sources\n        // correctly (other microtasks won't affect the duration).\n        awaitIfAsync(source.bind(null, sourceOptions), (...loadArgs) => {\n            const loadDuration = Date.now() - loadStartTime;\n            // Source loading failed\n            if (!loadArgs[0]) {\n                return resolveLoad(() => ({ error: loadArgs[1], duration: loadDuration }));\n            }\n            const loadResult = loadArgs[1];\n            // Source loaded with the final result\n            if (isFinalResultLoaded(loadResult)) {\n                return resolveLoad(() => ({ value: loadResult, duration: loadDuration }));\n            }\n            // Source loaded with \"get\" stage\n            resolveLoad(() => new Promise((resolveGet) => {\n                const getStartTime = Date.now();\n                awaitIfAsync(loadResult, (...getArgs) => {\n                    const duration = loadDuration + Date.now() - getStartTime;\n                    // Source getting failed\n                    if (!getArgs[0]) {\n                        return resolveGet({ error: getArgs[1], duration });\n                    }\n                    // Source getting succeeded\n                    resolveGet({ value: getArgs[1], duration });\n                });\n            }));\n        });\n    }));\n    return function getComponent() {\n        return sourceLoadPromise.then((finalizeSource) => finalizeSource());\n    };\n}\n/**\n * Loads the given entropy sources. Returns a function that collects the entropy components.\n *\n * The result is returned synchronously in order to allow start getting the components\n * before the sources are loaded completely.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction loadSources(sources, sourceOptions, excludeSources, loopReleaseInterval) {\n    const includedSources = Object.keys(sources).filter((sourceKey) => excludes(excludeSources, sourceKey));\n    // Using `mapWithBreaks` allows asynchronous sources to complete between synchronous sources\n    // and measure the duration correctly\n    const sourceGettersPromise = suppressUnhandledRejectionWarning(mapWithBreaks(includedSources, (sourceKey) => loadSource(sources[sourceKey], sourceOptions), loopReleaseInterval));\n    return async function getComponents() {\n        const sourceGetters = await sourceGettersPromise;\n        const componentPromises = await mapWithBreaks(sourceGetters, (sourceGetter) => suppressUnhandledRejectionWarning(sourceGetter()), loopReleaseInterval);\n        const componentArray = await Promise.all(componentPromises);\n        // Keeping the component keys order the same as the source keys order\n        const components = {};\n        for (let index = 0; index < includedSources.length; ++index) {\n            components[includedSources[index]] = componentArray[index];\n        }\n        return components;\n    };\n}\n/**\n * Modifies an entropy source by transforming its returned value with the given function.\n * Keeps the source properties: sync/async, 1/2 stages.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction transformSource(source, transformValue) {\n    const transformLoadResult = (loadResult) => {\n        if (isFinalResultLoaded(loadResult)) {\n            return transformValue(loadResult);\n        }\n        return () => {\n            const getResult = loadResult();\n            if (isPromise(getResult)) {\n                return getResult.then(transformValue);\n            }\n            return transformValue(getResult);\n        };\n    };\n    return (options) => {\n        const loadResult = source(options);\n        if (isPromise(loadResult)) {\n            return loadResult.then(transformLoadResult);\n        }\n        return transformLoadResult(loadResult);\n    };\n}\n\n/*\n * Functions to help with features that vary through browsers\n */\n/**\n * Checks whether the browser is based on Trident (the Internet Explorer engine) without using user-agent.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isTrident() {\n    const w = window;\n    const n = navigator;\n    // The properties are checked to be in IE 10, IE 11 and not to be in other browsers in October 2020\n    return (countTruthy([\n        'MSCSSMatrix' in w,\n        'msSetImmediate' in w,\n        'msIndexedDB' in w,\n        'msMaxTouchPoints' in n,\n        'msPointerEnabled' in n,\n    ]) >= 4);\n}\n/**\n * Checks whether the browser is based on EdgeHTML (the pre-Chromium Edge engine) without using user-agent.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isEdgeHTML() {\n    // Based on research in October 2020\n    const w = window;\n    const n = navigator;\n    return (countTruthy(['msWriteProfilerMark' in w, 'MSStream' in w, 'msLaunchUri' in n, 'msSaveBlob' in n]) >= 3 &&\n        !isTrident());\n}\n/**\n * Checks whether the browser is based on Chromium without using user-agent.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isChromium() {\n    // Based on research in October 2020. Tested to detect Chromium 42-86.\n    const w = window;\n    const n = navigator;\n    return (countTruthy([\n        'webkitPersistentStorage' in n,\n        'webkitTemporaryStorage' in n,\n        (n.vendor || '').indexOf('Google') === 0,\n        'webkitResolveLocalFileSystemURL' in w,\n        'BatteryManager' in w,\n        'webkitMediaStream' in w,\n        'webkitSpeechGrammar' in w,\n    ]) >= 5);\n}\n/**\n * Checks whether the browser is based on mobile or desktop Safari without using user-agent.\n * All iOS browsers use WebKit (the Safari engine).\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isWebKit() {\n    // Based on research in August 2024\n    const w = window;\n    const n = navigator;\n    return (countTruthy([\n        'ApplePayError' in w,\n        'CSSPrimitiveValue' in w,\n        'Counter' in w,\n        n.vendor.indexOf('Apple') === 0,\n        'RGBColor' in w,\n        'WebKitMediaKeys' in w,\n    ]) >= 4);\n}\n/**\n * Checks whether this WebKit browser is a desktop browser.\n * It doesn't check that the browser is based on WebKit, there is a separate function for this.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isDesktopWebKit() {\n    // Checked in Safari and DuckDuckGo\n    const w = window;\n    const { HTMLElement, Document } = w;\n    return (countTruthy([\n        'safari' in w,\n        !('ongestureend' in w),\n        !('TouchEvent' in w),\n        !('orientation' in w),\n        HTMLElement && !('autocapitalize' in HTMLElement.prototype),\n        Document && 'pointerLockElement' in Document.prototype,\n    ]) >= 4);\n}\n/**\n * Checks whether this WebKit browser is Safari.\n * It doesn't check that the browser is based on WebKit, there is a separate function for this.\n *\n * Warning! The function works properly only for Safari version 15.4 and newer.\n */\nfunction isSafariWebKit() {\n    // Checked in Safari, Chrome, Firefox, Yandex, UC Browser, Opera, Edge and DuckDuckGo.\n    // iOS Safari and Chrome were checked on iOS 11-18. DuckDuckGo was checked on iOS 17-18 and macOS 14-15.\n    // Desktop Safari versions 12-18 were checked.\n    // The other browsers were checked on iOS 17 and 18; there was no chance to check them on the other OS versions.\n    const w = window;\n    return (\n    // Filters-out Chrome, Yandex, DuckDuckGo (macOS and iOS), Edge\n    isFunctionNative(w.print) &&\n        // Doesn't work in Safari < 15.4\n        String(w.browser) === '[object WebPageNamespace]');\n}\n/**\n * Checks whether the browser is based on Gecko (Firefox engine) without using user-agent.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isGecko() {\n    var _a, _b;\n    const w = window;\n    // Based on research in September 2020\n    return (countTruthy([\n        'buildID' in navigator,\n        'MozAppearance' in ((_b = (_a = document.documentElement) === null || _a === void 0 ? void 0 : _a.style) !== null && _b !== void 0 ? _b : {}),\n        'onmozfullscreenchange' in w,\n        'mozInnerScreenX' in w,\n        'CSSMozDocumentRule' in w,\n        'CanvasCaptureMediaStream' in w,\n    ]) >= 4);\n}\n/**\n * Checks whether the browser is based on Chromium version \u226586 without using user-agent.\n * It doesn't check that the browser is based on Chromium, there is a separate function for this.\n */\nfunction isChromium86OrNewer() {\n    // Checked in Chrome 85 vs Chrome 86 both on desktop and Android. Checked in macOS Chrome 128, Android Chrome 127.\n    const w = window;\n    return (countTruthy([\n        !('MediaSettingsRange' in w),\n        'RTCEncodedAudioFrame' in w,\n        '' + w.Intl === '[object Intl]',\n        '' + w.Reflect === '[object Reflect]',\n    ]) >= 3);\n}\n/**\n * Checks whether the browser is based on Chromium version \u2265122 without using user-agent.\n * It doesn't check that the browser is based on Chromium, there is a separate function for this.\n */\nfunction isChromium122OrNewer() {\n    // Checked in Chrome 121 vs Chrome 122 and 129 both on desktop and Android\n    const w = window;\n    const { URLPattern } = w;\n    return (countTruthy([\n        'union' in Set.prototype,\n        'Iterator' in w,\n        URLPattern && 'hasRegExpGroups' in URLPattern.prototype,\n        'RGB8' in WebGLRenderingContext.prototype,\n    ]) >= 3);\n}\n/**\n * Checks whether the browser is based on WebKit version \u2265606 (Safari \u226512) without using user-agent.\n * It doesn't check that the browser is based on WebKit, there is a separate function for this.\n *\n * @see https://en.wikipedia.org/wiki/Safari_version_history#Release_history Safari-WebKit versions map\n */\nfunction isWebKit606OrNewer() {\n    // Checked in Safari 9\u201318\n    const w = window;\n    return (countTruthy([\n        'DOMRectList' in w,\n        'RTCPeerConnectionIceEvent' in w,\n        'SVGGeometryElement' in w,\n        'ontransitioncancel' in w,\n    ]) >= 3);\n}\n/**\n * Checks whether the browser is based on WebKit version \u2265616 (Safari \u226517) without using user-agent.\n * It doesn't check that the browser is based on WebKit, there is a separate function for this.\n *\n * @see https://developer.apple.com/documentation/safari-release-notes/safari-17-release-notes Safari 17 release notes\n * @see https://tauri.app/v1/references/webview-versions/#webkit-versions-in-safari Safari-WebKit versions map\n */\nfunction isWebKit616OrNewer() {\n    const w = window;\n    const n = navigator;\n    const { CSS, HTMLButtonElement } = w;\n    return (countTruthy([\n        !('getStorageUpdates' in n),\n        HTMLButtonElement && 'popover' in HTMLButtonElement.prototype,\n        'CSSCounterStyleRule' in w,\n        CSS.supports('font-size-adjust: ex-height 0.5'),\n        CSS.supports('text-transform: full-width'),\n    ]) >= 4);\n}\n/**\n * Checks whether the device is an iPad.\n * It doesn't check that the engine is WebKit and that the WebKit isn't desktop.\n */\nfunction isIPad() {\n    // Checked on:\n    // Safari on iPadOS (both mobile and desktop modes): 8, 11-18\n    // Chrome on iPadOS (both mobile and desktop modes): 11-18\n    // Safari on iOS (both mobile and desktop modes): 9-18\n    // Chrome on iOS (both mobile and desktop modes): 9-18\n    // Before iOS 13. Safari tampers the value in \"request desktop site\" mode since iOS 13.\n    if (navigator.platform === 'iPad') {\n        return true;\n    }\n    const s = screen;\n    const screenRatio = s.width / s.height;\n    return (countTruthy([\n        // Since iOS 13. Doesn't work in Chrome on iPadOS <15, but works in desktop mode.\n        'MediaSource' in window,\n        // Since iOS 12. Doesn't work in Chrome on iPadOS.\n        !!Element.prototype.webkitRequestFullscreen,\n        // iPhone 4S that runs iOS 9 matches this, but it is not supported\n        // Doesn't work in incognito mode of Safari \u226517 with split screen because of tracking prevention\n        screenRatio > 0.65 && screenRatio < 1.53,\n    ]) >= 2);\n}\n/**\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction getFullscreenElement() {\n    const d = document;\n    return d.fullscreenElement || d.msFullscreenElement || d.mozFullScreenElement || d.webkitFullscreenElement || null;\n}\nfunction exitFullscreen() {\n    const d = document;\n    // `call` is required because the function throws an error without a proper \"this\" context\n    return (d.exitFullscreen || d.msExitFullscreen || d.mozCancelFullScreen || d.webkitExitFullscreen).call(d);\n}\n/**\n * Checks whether the device runs on Android without using user-agent.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isAndroid() {\n    const isItChromium = isChromium();\n    const isItGecko = isGecko();\n    const w = window;\n    const n = navigator;\n    const c = 'connection';\n    // Chrome removes all words \"Android\" from `navigator` when desktop version is requested\n    // Firefox keeps \"Android\" in `navigator.appVersion` when desktop version is requested\n    if (isItChromium) {\n        return (countTruthy([\n            !('SharedWorker' in w),\n            // `typechange` is deprecated, but it's still present on Android (tested on Chrome Mobile 117)\n            // Removal proposal https://bugs.chromium.org/p/chromium/issues/detail?id=699892\n            // Note: this expression returns true on ChromeOS, so additional detectors are required to avoid false-positives\n            n[c] && 'ontypechange' in n[c],\n            !('sinkId' in new Audio()),\n        ]) >= 2);\n    }\n    else if (isItGecko) {\n        return countTruthy(['onorientationchange' in w, 'orientation' in w, /android/i.test(n.appVersion)]) >= 2;\n    }\n    else {\n        // Only 2 browser engines are presented on Android.\n        // Actually, there is also Android 4.1 browser, but it's not worth detecting it at the moment.\n        return false;\n    }\n}\n/**\n * Checks whether the browser is Samsung Internet without using user-agent.\n * It doesn't check that the browser is based on Chromium, please use `isChromium` before using this function.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction isSamsungInternet() {\n    // Checked in Samsung Internet 21, 25 and 27\n    const n = navigator;\n    const w = window;\n    const audioPrototype = Audio.prototype;\n    const { visualViewport } = w;\n    return (countTruthy([\n        'srLatency' in audioPrototype,\n        'srChannelCount' in audioPrototype,\n        'devicePosture' in n,\n        visualViewport && 'segments' in visualViewport,\n        'getTextInformation' in Image.prototype, // Not available in Samsung Internet 21\n    ]) >= 3);\n}\n\n/**\n * A deep description: https://fingerprint.com/blog/audio-fingerprinting/\n * Inspired by and based on https://github.com/cozylife/audio-fingerprint\n *\n * A version of the entropy source with stabilization to make it suitable for static fingerprinting.\n * Audio signal is noised in private mode of Safari 17, so audio fingerprinting is skipped in Safari 17.\n */\nfunction getAudioFingerprint() {\n    if (doesBrowserPerformAntifingerprinting$1()) {\n        return -4 /* SpecialFingerprint.KnownForAntifingerprinting */;\n    }\n    return getUnstableAudioFingerprint();\n}\n/**\n * A version of the entropy source without stabilization.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction getUnstableAudioFingerprint() {\n    const w = window;\n    const AudioContext = w.OfflineAudioContext || w.webkitOfflineAudioContext;\n    if (!AudioContext) {\n        return -2 /* SpecialFingerprint.NotSupported */;\n    }\n    // In some browsers, audio context always stays suspended unless the context is started in response to a user action\n    // (e.g. a click or a tap). It prevents audio fingerprint from being taken at an arbitrary moment of time.\n    // Such browsers are old and unpopular, so the audio fingerprinting is just skipped in them.\n    // See a similar case explanation at https://stackoverflow.com/questions/46363048/onaudioprocess-not-called-on-ios11#46534088\n    if (doesBrowserSuspendAudioContext()) {\n        return -1 /* SpecialFingerprint.KnownForSuspending */;\n    }\n    const hashFromIndex = 4500;\n    const hashToIndex = 5000;\n    const context = new AudioContext(1, hashToIndex, 44100);\n    const oscillator = context.createOscillator();\n    oscillator.type = 'triangle';\n    oscillator.frequency.value = 10000;\n    const compressor = context.createDynamicsCompressor();\n    compressor.threshold.value = -50;\n    compressor.knee.value = 40;\n    compressor.ratio.value = 12;\n    compressor.attack.value = 0;\n    compressor.release.value = 0.25;\n    oscillator.connect(compressor);\n    compressor.connect(context.destination);\n    oscillator.start(0);\n    const [renderPromise, finishRendering] = startRenderingAudio(context);\n    // Suppresses the console error message in case when the fingerprint fails before requested\n    const fingerprintPromise = suppressUnhandledRejectionWarning(renderPromise.then((buffer) => getHash(buffer.getChannelData(0).subarray(hashFromIndex)), (error) => {\n        if (error.name === \"timeout\" /* InnerErrorName.Timeout */ || error.name === \"suspended\" /* InnerErrorName.Suspended */) {\n            return -3 /* SpecialFingerprint.Timeout */;\n        }\n        throw error;\n    }));\n    return () => {\n        finishRendering();\n        return fingerprintPromise;\n    };\n}\n/**\n * Checks if the current browser is known for always suspending audio context\n */\nfunction doesBrowserSuspendAudioContext() {\n    // Mobile Safari 11 and older\n    return isWebKit() && !isDesktopWebKit() && !isWebKit606OrNewer();\n}\n/**\n * Checks if the current browser is known for applying anti-fingerprinting measures in all or some critical modes\n */\nfunction doesBrowserPerformAntifingerprinting$1() {\n    return (\n    // Safari \u226517\n    (isWebKit() && isWebKit616OrNewer() && isSafariWebKit()) ||\n        // Samsung Internet \u226526\n        (isChromium() && isSamsungInternet() && isChromium122OrNewer()));\n}\n/**\n * Starts rendering the audio context.\n * When the returned function is called, the render process starts finishing.\n */\nfunction startRenderingAudio(context) {\n    const renderTryMaxCount = 3;\n    const renderRetryDelay = 500;\n    const runningMaxAwaitTime = 500;\n    const runningSufficientTime = 5000;\n    let finalize = () => undefined;\n    const resultPromise = new Promise((resolve, reject) => {\n        let isFinalized = false;\n        let renderTryCount = 0;\n        let startedRunningAt = 0;\n        context.oncomplete = (event) => resolve(event.renderedBuffer);\n        const startRunningTimeout = () => {\n            setTimeout(() => reject(makeInnerError(\"timeout\" /* InnerErrorName.Timeout */)), Math.min(runningMaxAwaitTime, startedRunningAt + runningSufficientTime - Date.now()));\n        };\n        const tryRender = () => {\n            try {\n                const renderingPromise = context.startRendering();\n                // `context.startRendering` has two APIs: Promise and callback, we check that it's really a promise just in case\n                if (isPromise(renderingPromise)) {\n                    // Suppresses all unhandled rejections in case of scheduled redundant retries after successful rendering\n                    suppressUnhandledRejectionWarning(renderingPromise);\n                }\n                switch (context.state) {\n                    case 'running':\n                        startedRunningAt = Date.now();\n                        if (isFinalized) {\n                            startRunningTimeout();\n                        }\n                        break;\n                    // Sometimes the audio context doesn't start after calling `startRendering` (in addition to the cases where\n                    // audio context doesn't start at all). A known case is starting an audio context when the browser tab is in\n                    // background on iPhone. Retries usually help in this case.\n                    case 'suspended':\n                        // The audio context can reject starting until the tab is in foreground. Long fingerprint duration\n                        // in background isn't a problem, therefore the retry attempts don't count in background. It can lead to\n                        // a situation when a fingerprint takes very long time and finishes successfully. FYI, the audio context\n                        // can be suspended when `document.hidden === false` and start running after a retry.\n                        if (!document.hidden) {\n                            renderTryCount++;\n                        }\n                        if (isFinalized && renderTryCount >= renderTryMaxCount) {\n                            reject(makeInnerError(\"suspended\" /* InnerErrorName.Suspended */));\n                        }\n                        else {\n                            setTimeout(tryRender, renderRetryDelay);\n                        }\n                        break;\n                }\n            }\n            catch (error) {\n                reject(error);\n            }\n        };\n        tryRender();\n        finalize = () => {\n            if (!isFinalized) {\n                isFinalized = true;\n                if (startedRunningAt > 0) {\n                    startRunningTimeout();\n                }\n            }\n        };\n    });\n    return [resultPromise, finalize];\n}\nfunction getHash(signal) {\n    let hash = 0;\n    for (let i = 0; i < signal.length; ++i) {\n        hash += Math.abs(signal[i]);\n    }\n    return hash;\n}\nfunction makeInnerError(name) {\n    const error = new Error(name);\n    error.name = name;\n    return error;\n}\n\n/**\n * Creates and keeps an invisible iframe while the given function runs.\n * The given function is called when the iframe is loaded and has a body.\n * The iframe allows to measure DOM sizes inside itself.\n *\n * Notice: passing an initial HTML code doesn't work in IE.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nasync function withIframe(action, initialHtml, domPollInterval = 50) {\n    var _a, _b, _c;\n    const d = document;\n    // document.body can be null while the page is loading\n    while (!d.body) {\n        await wait(domPollInterval);\n    }\n    const iframe = d.createElement('iframe');\n    try {\n        await new Promise((_resolve, _reject) => {\n            let isComplete = false;\n            const resolve = () => {\n                isComplete = true;\n                _resolve();\n            };\n            const reject = (error) => {\n                isComplete = true;\n                _reject(error);\n            };\n            iframe.onload = resolve;\n            iframe.onerror = reject;\n            const { style } = iframe;\n            style.setProperty('display', 'block', 'important'); // Required for browsers to calculate the layout\n            style.position = 'absolute';\n            style.top = '0';\n            style.left = '0';\n            style.visibility = 'hidden';\n            if (initialHtml && 'srcdoc' in iframe) {\n                iframe.srcdoc = initialHtml;\n            }\n            else {\n                iframe.src = 'about:blank';\n            }\n            d.body.appendChild(iframe);\n            // WebKit in WeChat doesn't fire the iframe's `onload` for some reason.\n            // This code checks for the loading state manually.\n            // See https://github.com/fingerprintjs/fingerprintjs/issues/645\n            const checkReadyState = () => {\n                var _a, _b;\n                // The ready state may never become 'complete' in Firefox despite the 'load' event being fired.\n                // So an infinite setTimeout loop can happen without this check.\n                // See https://github.com/fingerprintjs/fingerprintjs/pull/716#issuecomment-986898796\n                if (isComplete) {\n                    return;\n                }\n                // Make sure iframe.contentWindow and iframe.contentWindow.document are both loaded\n                // The contentWindow.document can miss in JSDOM (https://github.com/jsdom/jsdom).\n                if (((_b = (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.document) === null || _b === void 0 ? void 0 : _b.readyState) === 'complete') {\n                    resolve();\n                }\n                else {\n                    setTimeout(checkReadyState, 10);\n                }\n            };\n            checkReadyState();\n        });\n        while (!((_b = (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.document) === null || _b === void 0 ? void 0 : _b.body)) {\n            await wait(domPollInterval);\n        }\n        return await action(iframe, iframe.contentWindow);\n    }\n    finally {\n        (_c = iframe.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(iframe);\n    }\n}\n/**\n * Creates a DOM element that matches the given selector.\n * Only single element selector are supported (without operators like space, +, >, etc).\n */\nfunction selectorToElement(selector) {\n    const [tag, attributes] = parseSimpleCssSelector(selector);\n    const element = document.createElement(tag !== null && tag !== void 0 ? tag : 'div');\n    for (const name of Object.keys(attributes)) {\n        const value = attributes[name].join(' ');\n        // Changing the `style` attribute can cause a CSP error, therefore we change the `style.cssText` property.\n        // https://github.com/fingerprintjs/fingerprintjs/issues/733\n        if (name === 'style') {\n            addStyleString(element.style, value);\n        }\n        else {\n            element.setAttribute(name, value);\n        }\n    }\n    return element;\n}\n/**\n * Adds CSS styles from a string in such a way that doesn't trigger a CSP warning (unsafe-inline or unsafe-eval)\n */\nfunction addStyleString(style, source) {\n    // We don't use `style.cssText` because browsers must block it when no `unsafe-eval` CSP is presented: https://csplite.com/csp145/#w3c_note\n    // Even though the browsers ignore this standard, we don't use `cssText` just in case.\n    for (const property of source.split(';')) {\n        const match = /^\\s*([\\w-]+)\\s*:\\s*(.+?)(\\s*!([\\w-]+))?\\s*$/.exec(property);\n        if (match) {\n            const [, name, value, , priority] = match;\n            style.setProperty(name, value, priority || ''); // The last argument can't be undefined in IE11\n        }\n    }\n}\n/**\n * Returns true if the code runs in an iframe, and any parent page's origin doesn't match the current origin\n */\nfunction isAnyParentCrossOrigin() {\n    let currentWindow = window;\n    for (;;) {\n        const parentWindow = currentWindow.parent;\n        if (!parentWindow || parentWindow === currentWindow) {\n            return false; // The top page is reached\n        }\n        try {\n            if (parentWindow.location.origin !== currentWindow.location.origin) {\n                return true;\n            }\n        }\n        catch (error) {\n            // The error is thrown when `origin` is accessed on `parentWindow.location` when the parent is cross-origin\n            if (error instanceof Error && error.name === 'SecurityError') {\n                return true;\n            }\n            throw error;\n        }\n        currentWindow = parentWindow;\n    }\n}\n\n// We use m or w because these two characters take up the maximum width.\n// And we use a LLi so that the same matching fonts can get separated.\nconst testString = 'mmMwWLliI0O&1';\n// We test using 48px font size, we may use any size. I guess larger the better.\nconst textSize = '48px';\n// A font will be compared against all the three default fonts.\n// And if for any default fonts it doesn't match, then that font is available.\nconst baseFonts = ['monospace', 'sans-serif', 'serif'];\nconst fontList = [\n    // This is android-specific font from \"Roboto\" family\n    'sans-serif-thin',\n    'ARNO PRO',\n    'Agency FB',\n    'Arabic Typesetting',\n    'Arial Unicode MS',\n    'AvantGarde Bk BT',\n    'BankGothic Md BT',\n    'Batang',\n    'Bitstream Vera Sans Mono',\n    'Calibri',\n    'Century',\n    'Century Gothic',\n    'Clarendon',\n    'EUROSTILE',\n    'Franklin Gothic',\n    'Futura Bk BT',\n    'Futura Md BT',\n    'GOTHAM',\n    'Gill Sans',\n    'HELV',\n    'Haettenschweiler',\n    'Helvetica Neue',\n    'Humanst521 BT',\n    'Leelawadee',\n    'Letter Gothic',\n    'Levenim MT',\n    'Lucida Bright',\n    'Lucida Sans',\n    'Menlo',\n    'MS Mincho',\n    'MS Outlook',\n    'MS Reference Specialty',\n    'MS UI Gothic',\n    'MT Extra',\n    'MYRIAD PRO',\n    'Marlett',\n    'Meiryo UI',\n    'Microsoft Uighur',\n    'Minion Pro',\n    'Monotype Corsiva',\n    'PMingLiU',\n    'Pristina',\n    'SCRIPTINA',\n    'Segoe UI Light',\n    'Serifa',\n    'SimHei',\n    'Small Fonts',\n    'Staccato222 BT',\n    'TRAJAN PRO',\n    'Univers CE 55 Medium',\n    'Vrinda',\n    'ZWAdobeF',\n];\n// kudos to http://www.lalit.org/lab/javascript-css-font-detect/\nfunction getFonts() {\n    // Running the script in an iframe makes it not affect the page look and not be affected by the page CSS. See:\n    // https://github.com/fingerprintjs/fingerprintjs/issues/592\n    // https://github.com/fingerprintjs/fingerprintjs/issues/628\n    return withIframe(async (_, { document }) => {\n        const holder = document.body;\n        holder.style.fontSize = textSize;\n        // div to load spans for the default fonts and the fonts to detect\n        const spansContainer = document.createElement('div');\n        spansContainer.style.setProperty('visibility', 'hidden', 'important');\n        const defaultWidth = {};\n        const defaultHeight = {};\n        // creates a span where the fonts will be loaded\n        const createSpan = (fontFamily) => {\n            const span = document.createElement('span');\n            const { style } = span;\n            style.position = 'absolute';\n            style.top = '0';\n            style.left = '0';\n            style.fontFamily = fontFamily;\n            span.textContent = testString;\n            spansContainer.appendChild(span);\n            return span;\n        };\n        // creates a span and load the font to detect and a base font for fallback\n        const createSpanWithFonts = (fontToDetect, baseFont) => {\n            return createSpan(`'${fontToDetect}',${baseFont}`);\n        };\n        // creates spans for the base fonts and adds them to baseFontsDiv\n        const initializeBaseFontsSpans = () => {\n            return baseFonts.map(createSpan);\n        };\n        // creates spans for the fonts to detect and adds them to fontsDiv\n        const initializeFontsSpans = () => {\n            // Stores {fontName : [spans for that font]}\n            const spans = {};\n            for (const font of fontList) {\n                spans[font] = baseFonts.map((baseFont) => createSpanWithFonts(font, baseFont));\n            }\n            return spans;\n        };\n        // checks if a font is available\n        const isFontAvailable = (fontSpans) => {\n            return baseFonts.some((baseFont, baseFontIndex) => fontSpans[baseFontIndex].offsetWidth !== defaultWidth[baseFont] ||\n                fontSpans[baseFontIndex].offsetHeight !== defaultHeight[baseFont]);\n        };\n        // create spans for base fonts\n        const baseFontsSpans = initializeBaseFontsSpans();\n        // create spans for fonts to detect\n        const fontsSpans = initializeFontsSpans();\n        // add all the spans to the DOM\n        holder.appendChild(spansContainer);\n        // get the default width for the three base fonts\n        for (let index = 0; index < baseFonts.length; index++) {\n            defaultWidth[baseFonts[index]] = baseFontsSpans[index].offsetWidth; // width for the default font\n            defaultHeight[baseFonts[index]] = baseFontsSpans[index].offsetHeight; // height for the default font\n        }\n        // check available fonts\n        return fontList.filter((font) => isFontAvailable(fontsSpans[font]));\n    });\n}\n\nfunction getPlugins() {\n    const rawPlugins = navigator.plugins;\n    if (!rawPlugins) {\n        return undefined;\n    }\n    const plugins = [];\n    // Safari 10 doesn't support iterating navigator.plugins with for...of\n    for (let i = 0; i < rawPlugins.length; ++i) {\n        const plugin = rawPlugins[i];\n        if (!plugin) {\n            continue;\n        }\n        const mimeTypes = [];\n        for (let j = 0; j < plugin.length; ++j) {\n            const mimeType = plugin[j];\n            mimeTypes.push({\n                type: mimeType.type,\n                suffixes: mimeType.suffixes,\n            });\n        }\n        plugins.push({\n            name: plugin.name,\n            description: plugin.description,\n            mimeTypes,\n        });\n    }\n    return plugins;\n}\n\n/**\n * @see https://www.browserleaks.com/canvas#how-does-it-work\n *\n * A version of the entropy source with stabilization to make it suitable for static fingerprinting.\n * Canvas image is noised in private mode of Safari 17, so image rendering is skipped in Safari 17.\n */\nfunction getCanvasFingerprint() {\n    return getUnstableCanvasFingerprint(doesBrowserPerformAntifingerprinting());\n}\n/**\n * A version of the entropy source without stabilization.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction getUnstableCanvasFingerprint(skipImages) {\n    let winding = false;\n    let geometry;\n    let text;\n    const [canvas, context] = makeCanvasContext();\n    if (!isSupported(canvas, context)) {\n        geometry = text = \"unsupported\" /* ImageStatus.Unsupported */;\n    }\n    else {\n        winding = doesSupportWinding(context);\n        if (skipImages) {\n            geometry = text = \"skipped\" /* ImageStatus.Skipped */;\n        }\n        else {\n            [geometry, text] = renderImages(canvas, context);\n        }\n    }\n    return { winding, geometry, text };\n}\nfunction makeCanvasContext() {\n    const canvas = document.createElement('canvas');\n    canvas.width = 1;\n    canvas.height = 1;\n    return [canvas, canvas.getContext('2d')];\n}\nfunction isSupported(canvas, context) {\n    return !!(context && canvas.toDataURL);\n}\nfunction doesSupportWinding(context) {\n    // https://web.archive.org/web/20170825024655/http://blogs.adobe.com/webplatform/2013/01/30/winding-rules-in-canvas/\n    // https://github.com/Modernizr/Modernizr/blob/master/feature-detects/canvas/winding.js\n    context.rect(0, 0, 10, 10);\n    context.rect(2, 2, 6, 6);\n    return !context.isPointInPath(5, 5, 'evenodd');\n}\nfunction renderImages(canvas, context) {\n    renderTextImage(canvas, context);\n    const textImage1 = canvasToString(canvas);\n    const textImage2 = canvasToString(canvas); // It's slightly faster to double-encode the text image\n    // Some browsers add a noise to the canvas: https://github.com/fingerprintjs/fingerprintjs/issues/791\n    // The canvas is excluded from the fingerprint in this case\n    if (textImage1 !== textImage2) {\n        return [\"unstable\" /* ImageStatus.Unstable */, \"unstable\" /* ImageStatus.Unstable */];\n    }\n    // Text is unstable:\n    // https://github.com/fingerprintjs/fingerprintjs/issues/583\n    // https://github.com/fingerprintjs/fingerprintjs/issues/103\n    // Therefore it's extracted into a separate image.\n    renderGeometryImage(canvas, context);\n    const geometryImage = canvasToString(canvas);\n    return [geometryImage, textImage1];\n}\nfunction renderTextImage(canvas, context) {\n    // Resizing the canvas cleans it\n    canvas.width = 240;\n    canvas.height = 60;\n    context.textBaseline = 'alphabetic';\n    context.fillStyle = '#f60';\n    context.fillRect(100, 1, 62, 20);\n    context.fillStyle = '#069';\n    // It's important to use explicit built-in fonts in order to exclude the affect of font preferences\n    // (there is a separate entropy source for them).\n    context.font = '11pt \"Times New Roman\"';\n    // The choice of emojis has a gigantic impact on rendering performance (especially in FF).\n    // Some newer emojis cause it to slow down 50-200 times.\n    // There must be no text to the right of the emoji, see https://github.com/fingerprintjs/fingerprintjs/issues/574\n    // A bare emoji shouldn't be used because the canvas will change depending on the script encoding:\n    // https://github.com/fingerprintjs/fingerprintjs/issues/66\n    // Escape sequence shouldn't be used too because Terser will turn it into a bare unicode.\n    const printedText = `Cwm fjordbank gly ${String.fromCharCode(55357, 56835) /* \uD83D\uDE03 */}`;\n    context.fillText(printedText, 2, 15);\n    context.fillStyle = 'rgba(102, 204, 0, 0.2)';\n    context.font = '18pt Arial';\n    context.fillText(printedText, 4, 45);\n}\nfunction renderGeometryImage(canvas, context) {\n    // Resizing the canvas cleans it\n    canvas.width = 122;\n    canvas.height = 110;\n    // Canvas blending\n    // https://web.archive.org/web/20170826194121/http://blogs.adobe.com/webplatform/2013/01/28/blending-features-in-canvas/\n    // http://jsfiddle.net/NDYV8/16/\n    context.globalCompositeOperation = 'multiply';\n    for (const [color, x, y] of [\n        ['#f2f', 40, 40],\n        ['#2ff', 80, 40],\n        ['#ff2', 60, 80],\n    ]) {\n        context.fillStyle = color;\n        context.beginPath();\n        context.arc(x, y, 40, 0, Math.PI * 2, true);\n        context.closePath();\n        context.fill();\n    }\n    // Canvas winding\n    // https://web.archive.org/web/20130913061632/http://blogs.adobe.com/webplatform/2013/01/30/winding-rules-in-canvas/\n    // http://jsfiddle.net/NDYV8/19/\n    context.fillStyle = '#f9c';\n    context.arc(60, 60, 60, 0, Math.PI * 2, true);\n    context.arc(60, 60, 20, 0, Math.PI * 2, true);\n    context.fill('evenodd');\n}\nfunction canvasToString(canvas) {\n    return canvas.toDataURL();\n}\n/**\n * Checks if the current browser is known for applying anti-fingerprinting measures in all or some critical modes\n */\nfunction doesBrowserPerformAntifingerprinting() {\n    // Safari 17\n    return isWebKit() && isWebKit616OrNewer() && isSafariWebKit();\n}\n\n/**\n * This is a crude and primitive touch screen detection. It's not possible to currently reliably detect the availability\n * of a touch screen with a JS, without actually subscribing to a touch event.\n *\n * @see http://www.stucox.com/blog/you-cant-detect-a-touchscreen/\n * @see https://github.com/Modernizr/Modernizr/issues/548\n */\nfunction getTouchSupport() {\n    const n = navigator;\n    let maxTouchPoints = 0;\n    let touchEvent;\n    if (n.maxTouchPoints !== undefined) {\n        maxTouchPoints = toInt(n.maxTouchPoints);\n    }\n    else if (n.msMaxTouchPoints !== undefined) {\n        maxTouchPoints = n.msMaxTouchPoints;\n    }\n    try {\n        document.createEvent('TouchEvent');\n        touchEvent = true;\n    }\n    catch (_a) {\n        touchEvent = false;\n    }\n    const touchStart = 'ontouchstart' in window;\n    return {\n        maxTouchPoints,\n        touchEvent,\n        touchStart,\n    };\n}\n\nfunction getOsCpu() {\n    return navigator.oscpu;\n}\n\nfunction getLanguages() {\n    const n = navigator;\n    const result = [];\n    const language = n.language || n.userLanguage || n.browserLanguage || n.systemLanguage;\n    if (language !== undefined) {\n        result.push([language]);\n    }\n    if (Array.isArray(n.languages)) {\n        // Starting from Chromium 86, there is only a single value in `navigator.language` in Incognito mode:\n        // the value of `navigator.language`. Therefore the value is ignored in this browser.\n        if (!(isChromium() && isChromium86OrNewer())) {\n            result.push(n.languages);\n        }\n    }\n    else if (typeof n.languages === 'string') {\n        const languages = n.languages;\n        if (languages) {\n            result.push(languages.split(','));\n        }\n    }\n    return result;\n}\n\nfunction getColorDepth() {\n    return window.screen.colorDepth;\n}\n\nfunction getDeviceMemory() {\n    // `navigator.deviceMemory` is a string containing a number in some unidentified cases\n    return replaceNaN(toFloat(navigator.deviceMemory), undefined);\n}\n\n/**\n * A version of the entropy source with stabilization to make it suitable for static fingerprinting.\n * The window resolution is always the document size in private mode of Safari 17,\n * so the window resolution is not used in Safari 17.\n */\nfunction getScreenResolution() {\n    if (isWebKit() && isWebKit616OrNewer() && isSafariWebKit()) {\n        return undefined;\n    }\n    return getUnstableScreenResolution();\n}\n/**\n * A version of the entropy source without stabilization.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction getUnstableScreenResolution() {\n    const s = screen;\n    // Some browsers return screen resolution as strings, e.g. \"1200\", instead of a number, e.g. 1200.\n    // I suspect it's done by certain plugins that randomize browser properties to prevent fingerprinting.\n    // Some browsers even return  screen resolution as not numbers.\n    const parseDimension = (value) => replaceNaN(toInt(value), null);\n    const dimensions = [parseDimension(s.width), parseDimension(s.height)];\n    dimensions.sort().reverse();\n    return dimensions;\n}\n\nconst screenFrameCheckInterval = 2500;\nconst roundingPrecision = 10;\n// The type is readonly to protect from unwanted mutations\nlet screenFrameBackup;\nlet screenFrameSizeTimeoutId;\n/**\n * Starts watching the screen frame size. When a non-zero size appears, the size is saved and the watch is stopped.\n * Later, when `getScreenFrame` runs, it will return the saved non-zero size if the current size is null.\n *\n * This trick is required to mitigate the fact that the screen frame turns null in some cases.\n * See more on this at https://github.com/fingerprintjs/fingerprintjs/issues/568\n */\nfunction watchScreenFrame() {\n    if (screenFrameSizeTimeoutId !== undefined) {\n        return;\n    }\n    const checkScreenFrame = () => {\n        const frameSize = getCurrentScreenFrame();\n        if (isFrameSizeNull(frameSize)) {\n            screenFrameSizeTimeoutId = setTimeout(checkScreenFrame, screenFrameCheckInterval);\n        }\n        else {\n            screenFrameBackup = frameSize;\n            screenFrameSizeTimeoutId = undefined;\n        }\n    };\n    checkScreenFrame();\n}\n/**\n * A version of the entropy source without stabilization.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction getUnstableScreenFrame() {\n    watchScreenFrame();\n    return async () => {\n        let frameSize = getCurrentScreenFrame();\n        if (isFrameSizeNull(frameSize)) {\n            if (screenFrameBackup) {\n                return [...screenFrameBackup];\n            }\n            if (getFullscreenElement()) {\n                // Some browsers set the screen frame to zero when programmatic fullscreen is on.\n                // There is a chance of getting a non-zero frame after exiting the fullscreen.\n                // See more on this at https://github.com/fingerprintjs/fingerprintjs/issues/568\n                await exitFullscreen();\n                frameSize = getCurrentScreenFrame();\n            }\n        }\n        if (!isFrameSizeNull(frameSize)) {\n            screenFrameBackup = frameSize;\n        }\n        return frameSize;\n    };\n}\n/**\n * A version of the entropy source with stabilization to make it suitable for static fingerprinting.\n *\n * Sometimes the available screen resolution changes a bit, e.g. 1900x1440 \u2192 1900x1439. A possible reason: macOS Dock\n * shrinks to fit more icons when there is too little space. The rounding is used to mitigate the difference.\n *\n * The frame width is always 0 in private mode of Safari 17, so the frame is not used in Safari 17.\n */\nfunction getScreenFrame() {\n    if (isWebKit() && isWebKit616OrNewer() && isSafariWebKit()) {\n        return () => Promise.resolve(undefined);\n    }\n    const screenFrameGetter = getUnstableScreenFrame();\n    return async () => {\n        const frameSize = await screenFrameGetter();\n        const processSize = (sideSize) => (sideSize === null ? null : round(sideSize, roundingPrecision));\n        // It might look like I don't know about `for` and `map`.\n        // In fact, such code is used to avoid TypeScript issues without using `as`.\n        return [processSize(frameSize[0]), processSize(frameSize[1]), processSize(frameSize[2]), processSize(frameSize[3])];\n    };\n}\nfunction getCurrentScreenFrame() {\n    const s = screen;\n    // Some browsers return screen resolution as strings, e.g. \"1200\", instead of a number, e.g. 1200.\n    // I suspect it's done by certain plugins that randomize browser properties to prevent fingerprinting.\n    //\n    // Some browsers (IE, Edge \u226418) don't provide `screen.availLeft` and `screen.availTop`. The property values are\n    // replaced with 0 in such cases to not lose the entropy from `screen.availWidth` and `screen.availHeight`.\n    return [\n        replaceNaN(toFloat(s.availTop), null),\n        replaceNaN(toFloat(s.width) - toFloat(s.availWidth) - replaceNaN(toFloat(s.availLeft), 0), null),\n        replaceNaN(toFloat(s.height) - toFloat(s.availHeight) - replaceNaN(toFloat(s.availTop), 0), null),\n        replaceNaN(toFloat(s.availLeft), null),\n    ];\n}\nfunction isFrameSizeNull(frameSize) {\n    for (let i = 0; i < 4; ++i) {\n        if (frameSize[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction getHardwareConcurrency() {\n    // sometimes hardware concurrency is a string\n    return replaceNaN(toInt(navigator.hardwareConcurrency), undefined);\n}\n\nfunction getTimezone() {\n    var _a;\n    const DateTimeFormat = (_a = window.Intl) === null || _a === void 0 ? void 0 : _a.DateTimeFormat;\n    if (DateTimeFormat) {\n        const timezone = new DateTimeFormat().resolvedOptions().timeZone;\n        if (timezone) {\n            return timezone;\n        }\n    }\n    // For browsers that don't support timezone names\n    // The minus is intentional because the JS offset is opposite to the real offset\n    const offset = -getTimezoneOffset();\n    return `UTC${offset >= 0 ? '+' : ''}${offset}`;\n}\nfunction getTimezoneOffset() {\n    const currentYear = new Date().getFullYear();\n    // The timezone offset may change over time due to daylight saving time (DST) shifts.\n    // The non-DST timezone offset is used as the result timezone offset.\n    // Since the DST season differs in the northern and the southern hemispheres,\n    // both January and July timezones offsets are considered.\n    return Math.max(\n    // `getTimezoneOffset` returns a number as a string in some unidentified cases\n    toFloat(new Date(currentYear, 0, 1).getTimezoneOffset()), toFloat(new Date(currentYear, 6, 1).getTimezoneOffset()));\n}\n\nfunction getSessionStorage() {\n    try {\n        return !!window.sessionStorage;\n    }\n    catch (error) {\n        /* SecurityError when referencing it means it exists */\n        return true;\n    }\n}\n\n// https://bugzilla.mozilla.org/show_bug.cgi?id=781447\nfunction getLocalStorage() {\n    try {\n        return !!window.localStorage;\n    }\n    catch (e) {\n        /* SecurityError when referencing it means it exists */\n        return true;\n    }\n}\n\nfunction getIndexedDB() {\n    // IE and Edge don't allow accessing indexedDB in private mode, therefore IE and Edge will have different\n    // visitor identifier in normal and private modes.\n    if (isTrident() || isEdgeHTML()) {\n        return undefined;\n    }\n    try {\n        return !!window.indexedDB;\n    }\n    catch (e) {\n        /* SecurityError when referencing it means it exists */\n        return true;\n    }\n}\n\nfunction getOpenDatabase() {\n    return !!window.openDatabase;\n}\n\nfunction getCpuClass() {\n    return navigator.cpuClass;\n}\n\nfunction getPlatform() {\n    // Android Chrome 86 and 87 and Android Firefox 80 and 84 don't mock the platform value when desktop mode is requested\n    const { platform } = navigator;\n    // iOS mocks the platform value when desktop version is requested: https://github.com/fingerprintjs/fingerprintjs/issues/514\n    // iPad uses desktop mode by default since iOS 13\n    // The value is 'MacIntel' on M1 Macs\n    // The value is 'iPhone' on iPod Touch\n    if (platform === 'MacIntel') {\n        if (isWebKit() && !isDesktopWebKit()) {\n            return isIPad() ? 'iPad' : 'iPhone';\n        }\n    }\n    return platform;\n}\n\nfunction getVendor() {\n    return navigator.vendor || '';\n}\n\n/**\n * Checks for browser-specific (not engine specific) global variables to tell browsers with the same engine apart.\n * Only somewhat popular browsers are considered.\n */\nfunction getVendorFlavors() {\n    const flavors = [];\n    for (const key of [\n        // Blink and some browsers on iOS\n        'chrome',\n        // Safari on macOS\n        'safari',\n        // Chrome on iOS (checked in 85 on 13 and 87 on 14)\n        '__crWeb',\n        '__gCrWeb',\n        // Yandex Browser on iOS, macOS and Android (checked in 21.2 on iOS 14, macOS and Android)\n        'yandex',\n        // Yandex Browser on iOS (checked in 21.2 on 14)\n        '__yb',\n        '__ybro',\n        // Firefox on iOS (checked in 32 on 14)\n        '__firefox__',\n        // Edge on iOS (checked in 46 on 14)\n        '__edgeTrackingPreventionStatistics',\n        'webkit',\n        // Opera Touch on iOS (checked in 2.6 on 14)\n        'oprt',\n        // Samsung Internet on Android (checked in 11.1)\n        'samsungAr',\n        // UC Browser on Android (checked in 12.10 and 13.0)\n        'ucweb',\n        'UCShellJava',\n        // Puffin on Android (checked in 9.0)\n        'puffinDevice',\n        // UC on iOS and Opera on Android have no specific global variables\n        // Edge for Android isn't checked\n    ]) {\n        const value = window[key];\n        if (value && typeof value === 'object') {\n            flavors.push(key);\n        }\n    }\n    return flavors.sort();\n}\n\n/**\n * navigator.cookieEnabled cannot detect custom or nuanced cookie blocking configurations. For example, when blocking\n * cookies via the Advanced Privacy Settings in IE9, it always returns true. And there have been issues in the past with\n * site-specific exceptions. Don't rely on it.\n *\n * @see https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cookies.js Taken from here\n */\nfunction areCookiesEnabled() {\n    const d = document;\n    // Taken from here: https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cookies.js\n    // navigator.cookieEnabled cannot detect custom or nuanced cookie blocking configurations. For example, when blocking\n    // cookies via the Advanced Privacy Settings in IE9, it always returns true. And there have been issues in the past\n    // with site-specific exceptions. Don't rely on it.\n    // try..catch because some in situations `document.cookie` is exposed but throws a\n    // SecurityError if you try to access it; e.g. documents created from data URIs\n    // or in sandboxed iframes (depending on flags/context)\n    try {\n        // Create cookie\n        d.cookie = 'cookietest=1; SameSite=Strict;';\n        const result = d.cookie.indexOf('cookietest=') !== -1;\n        // Delete cookie\n        d.cookie = 'cookietest=1; SameSite=Strict; expires=Thu, 01-Jan-1970 00:00:01 GMT';\n        return result;\n    }\n    catch (e) {\n        return false;\n    }\n}\n\n/**\n * Only single element selector are supported (no operators like space, +, >, etc).\n * `embed` and `position: fixed;` will be considered as blocked anyway because it always has no offsetParent.\n * Avoid `iframe` and anything with `[src=]` because they produce excess HTTP requests.\n *\n * The \"inappropriate\" selectors are obfuscated. See https://github.com/fingerprintjs/fingerprintjs/issues/734.\n * A function is used instead of a plain object to help tree-shaking.\n *\n * The function code is generated automatically. See docs/content_blockers.md to learn how to make the list.\n */\nfunction getFilters() {\n    const fromB64 = atob; // Just for better minification\n    return {\n        abpIndo: [\n            '#Iklan-Melayang',\n            '#Kolom-Iklan-728',\n            '#SidebarIklan-wrapper',\n            '[title=\"ALIENBOLA\" i]',\n            fromB64('I0JveC1CYW5uZXItYWRz'),\n        ],\n        abpvn: ['.quangcao', '#mobileCatfish', fromB64('LmNsb3NlLWFkcw=='), '[id^=\"bn_bottom_fixed_\"]', '#pmadv'],\n        adBlockFinland: [\n            '.mainostila',\n            fromB64('LnNwb25zb3JpdA=='),\n            '.ylamainos',\n            fromB64('YVtocmVmKj0iL2NsaWNrdGhyZ2guYXNwPyJd'),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9hcHAucmVhZHBlYWsuY29tL2FkcyJd'),\n        ],\n        adBlockPersian: [\n            '#navbar_notice_50',\n            '.kadr',\n            'TABLE[width=\"140px\"]',\n            '#divAgahi',\n            fromB64('YVtocmVmXj0iaHR0cDovL2cxLnYuZndtcm0ubmV0L2FkLyJd'),\n        ],\n        adBlockWarningRemoval: [\n            '#adblock-honeypot',\n            '.adblocker-root',\n            '.wp_adblock_detect',\n            fromB64('LmhlYWRlci1ibG9ja2VkLWFk'),\n            fromB64('I2FkX2Jsb2NrZXI='),\n        ],\n        adGuardAnnoyances: [\n            '.hs-sosyal',\n            '#cookieconsentdiv',\n            'div[class^=\"app_gdpr\"]',\n            '.as-oil',\n            '[data-cypress=\"soft-push-notification-modal\"]',\n        ],\n        adGuardBase: [\n            '.BetterJsPopOverlay',\n            fromB64('I2FkXzMwMFgyNTA='),\n            fromB64('I2Jhbm5lcmZsb2F0MjI='),\n            fromB64('I2NhbXBhaWduLWJhbm5lcg=='),\n            fromB64('I0FkLUNvbnRlbnQ='),\n        ],\n        adGuardChinese: [\n            fromB64('LlppX2FkX2FfSA=='),\n            fromB64('YVtocmVmKj0iLmh0aGJldDM0LmNvbSJd'),\n            '#widget-quan',\n            fromB64('YVtocmVmKj0iLzg0OTkyMDIwLnh5eiJd'),\n            fromB64('YVtocmVmKj0iLjE5NTZobC5jb20vIl0='),\n        ],\n        adGuardFrench: [\n            '#pavePub',\n            fromB64('LmFkLWRlc2t0b3AtcmVjdGFuZ2xl'),\n            '.mobile_adhesion',\n            '.widgetadv',\n            fromB64('LmFkc19iYW4='),\n        ],\n        adGuardGerman: ['aside[data-portal-id=\"leaderboard\"]'],\n        adGuardJapanese: [\n            '#kauli_yad_1',\n            fromB64('YVtocmVmXj0iaHR0cDovL2FkMi50cmFmZmljZ2F0ZS5uZXQvIl0='),\n            fromB64('Ll9wb3BJbl9pbmZpbml0ZV9hZA=='),\n            fromB64('LmFkZ29vZ2xl'),\n            fromB64('Ll9faXNib29zdFJldHVybkFk'),\n        ],\n        adGuardMobile: [\n            fromB64('YW1wLWF1dG8tYWRz'),\n            fromB64('LmFtcF9hZA=='),\n            'amp-embed[type=\"24smi\"]',\n            '#mgid_iframe1',\n            fromB64('I2FkX2ludmlld19hcmVh'),\n        ],\n        adGuardRussian: [\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9hZC5sZXRtZWFkcy5jb20vIl0='),\n            fromB64('LnJlY2xhbWE='),\n            'div[id^=\"smi2adblock\"]',\n            fromB64('ZGl2W2lkXj0iQWRGb3hfYmFubmVyXyJd'),\n            '#psyduckpockeball',\n        ],\n        adGuardSocial: [\n            fromB64('YVtocmVmXj0iLy93d3cuc3R1bWJsZXVwb24uY29tL3N1Ym1pdD91cmw9Il0='),\n            fromB64('YVtocmVmXj0iLy90ZWxlZ3JhbS5tZS9zaGFyZS91cmw/Il0='),\n            '.etsy-tweet',\n            '#inlineShare',\n            '.popup-social',\n        ],\n        adGuardSpanishPortuguese: ['#barraPublicidade', '#Publicidade', '#publiEspecial', '#queTooltip', '.cnt-publi'],\n        adGuardTrackingProtection: [\n            '#qoo-counter',\n            fromB64('YVtocmVmXj0iaHR0cDovL2NsaWNrLmhvdGxvZy5ydS8iXQ=='),\n            fromB64('YVtocmVmXj0iaHR0cDovL2hpdGNvdW50ZXIucnUvdG9wL3N0YXQucGhwIl0='),\n            fromB64('YVtocmVmXj0iaHR0cDovL3RvcC5tYWlsLnJ1L2p1bXAiXQ=='),\n            '#top100counter',\n        ],\n        adGuardTurkish: [\n            '#backkapat',\n            fromB64('I3Jla2xhbWk='),\n            fromB64('YVtocmVmXj0iaHR0cDovL2Fkc2Vydi5vbnRlay5jb20udHIvIl0='),\n            fromB64('YVtocmVmXj0iaHR0cDovL2l6bGVuemkuY29tL2NhbXBhaWduLyJd'),\n            fromB64('YVtocmVmXj0iaHR0cDovL3d3dy5pbnN0YWxsYWRzLm5ldC8iXQ=='),\n        ],\n        bulgarian: [fromB64('dGQjZnJlZW5ldF90YWJsZV9hZHM='), '#ea_intext_div', '.lapni-pop-over', '#xenium_hot_offers'],\n        easyList: [\n            '.yb-floorad',\n            fromB64('LndpZGdldF9wb19hZHNfd2lkZ2V0'),\n            fromB64('LnRyYWZmaWNqdW5reS1hZA=='),\n            '.textad_headline',\n            fromB64('LnNwb25zb3JlZC10ZXh0LWxpbmtz'),\n        ],\n        easyListChina: [\n            fromB64('LmFwcGd1aWRlLXdyYXBbb25jbGljayo9ImJjZWJvcy5jb20iXQ=='),\n            fromB64('LmZyb250cGFnZUFkdk0='),\n            '#taotaole',\n            '#aafoot.top_box',\n            '.cfa_popup',\n        ],\n        easyListCookie: [\n            '.ezmob-footer',\n            '.cc-CookieWarning',\n            '[data-cookie-number]',\n            fromB64('LmF3LWNvb2tpZS1iYW5uZXI='),\n            '.sygnal24-gdpr-modal-wrap',\n        ],\n        easyListCzechSlovak: [\n            '#onlajny-stickers',\n            fromB64('I3Jla2xhbW5pLWJveA=='),\n            fromB64('LnJla2xhbWEtbWVnYWJvYXJk'),\n            '.sklik',\n            fromB64('W2lkXj0ic2tsaWtSZWtsYW1hIl0='),\n        ],\n        easyListDutch: [\n            fromB64('I2FkdmVydGVudGll'),\n            fromB64('I3ZpcEFkbWFya3RCYW5uZXJCbG9jaw=='),\n            '.adstekst',\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly94bHR1YmUubmwvY2xpY2svIl0='),\n            '#semilo-lrectangle',\n        ],\n        easyListGermany: [\n            '#SSpotIMPopSlider',\n            fromB64('LnNwb25zb3JsaW5rZ3J1ZW4='),\n            fromB64('I3dlcmJ1bmdza3k='),\n            fromB64('I3Jla2xhbWUtcmVjaHRzLW1pdHRl'),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9iZDc0Mi5jb20vIl0='),\n        ],\n        easyListItaly: [\n            fromB64('LmJveF9hZHZfYW5udW5jaQ=='),\n            '.sb-box-pubbliredazionale',\n            fromB64('YVtocmVmXj0iaHR0cDovL2FmZmlsaWF6aW9uaWFkcy5zbmFpLml0LyJd'),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9hZHNlcnZlci5odG1sLml0LyJd'),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9hZmZpbGlhemlvbmlhZHMuc25haS5pdC8iXQ=='),\n        ],\n        easyListLithuania: [\n            fromB64('LnJla2xhbW9zX3RhcnBhcw=='),\n            fromB64('LnJla2xhbW9zX251b3JvZG9z'),\n            fromB64('aW1nW2FsdD0iUmVrbGFtaW5pcyBza3lkZWxpcyJd'),\n            fromB64('aW1nW2FsdD0iRGVkaWt1b3RpLmx0IHNlcnZlcmlhaSJd'),\n            fromB64('aW1nW2FsdD0iSG9zdGluZ2FzIFNlcnZlcmlhaS5sdCJd'),\n        ],\n        estonian: [fromB64('QVtocmVmKj0iaHR0cDovL3BheTRyZXN1bHRzMjQuZXUiXQ==')],\n        fanboyAnnoyances: ['#ac-lre-player', '.navigate-to-top', '#subscribe_popup', '.newsletter_holder', '#back-top'],\n        fanboyAntiFacebook: ['.util-bar-module-firefly-visible'],\n        fanboyEnhancedTrackers: [\n            '.open.pushModal',\n            '#issuem-leaky-paywall-articles-zero-remaining-nag',\n            '#sovrn_container',\n            'div[class$=\"-hide\"][zoompage-fontsize][style=\"display: block;\"]',\n            '.BlockNag__Card',\n        ],\n        fanboySocial: ['#FollowUs', '#meteored_share', '#social_follow', '.article-sharer', '.community__social-desc'],\n        frellwitSwedish: [\n            fromB64('YVtocmVmKj0iY2FzaW5vcHJvLnNlIl1bdGFyZ2V0PSJfYmxhbmsiXQ=='),\n            fromB64('YVtocmVmKj0iZG9rdG9yLXNlLm9uZWxpbmsubWUiXQ=='),\n            'article.category-samarbete',\n            fromB64('ZGl2LmhvbGlkQWRz'),\n            'ul.adsmodern',\n        ],\n        greekAdBlock: [\n            fromB64('QVtocmVmKj0iYWRtYW4ub3RlbmV0LmdyL2NsaWNrPyJd'),\n            fromB64('QVtocmVmKj0iaHR0cDovL2F4aWFiYW5uZXJzLmV4b2R1cy5nci8iXQ=='),\n            fromB64('QVtocmVmKj0iaHR0cDovL2ludGVyYWN0aXZlLmZvcnRobmV0LmdyL2NsaWNrPyJd'),\n            'DIV.agores300',\n            'TABLE.advright',\n        ],\n        hungarian: [\n            '#cemp_doboz',\n            '.optimonk-iframe-container',\n            fromB64('LmFkX19tYWlu'),\n            fromB64('W2NsYXNzKj0iR29vZ2xlQWRzIl0='),\n            '#hirdetesek_box',\n        ],\n        iDontCareAboutCookies: [\n            '.alert-info[data-block-track*=\"CookieNotice\"]',\n            '.ModuleTemplateCookieIndicator',\n            '.o--cookies--container',\n            '#cookies-policy-sticky',\n            '#stickyCookieBar',\n        ],\n        icelandicAbp: [fromB64('QVtocmVmXj0iL2ZyYW1ld29yay9yZXNvdXJjZXMvZm9ybXMvYWRzLmFzcHgiXQ==')],\n        latvian: [\n            fromB64('YVtocmVmPSJodHRwOi8vd3d3LnNhbGlkemluaS5sdi8iXVtzdHlsZT0iZGlzcGxheTogYmxvY2s7IHdpZHRoOiAxMjBweDsgaGVpZ2h0O' +\n                'iA0MHB4OyBvdmVyZmxvdzogaGlkZGVuOyBwb3NpdGlvbjogcmVsYXRpdmU7Il0='),\n            fromB64('YVtocmVmPSJodHRwOi8vd3d3LnNhbGlkemluaS5sdi8iXVtzdHlsZT0iZGlzcGxheTogYmxvY2s7IHdpZHRoOiA4OHB4OyBoZWlnaHQ6I' +\n                'DMxcHg7IG92ZXJmbG93OiBoaWRkZW47IHBvc2l0aW9uOiByZWxhdGl2ZTsiXQ=='),\n        ],\n        listKr: [\n            fromB64('YVtocmVmKj0iLy9hZC5wbGFuYnBsdXMuY28ua3IvIl0='),\n            fromB64('I2xpdmVyZUFkV3JhcHBlcg=='),\n            fromB64('YVtocmVmKj0iLy9hZHYuaW1hZHJlcC5jby5rci8iXQ=='),\n            fromB64('aW5zLmZhc3R2aWV3LWFk'),\n            '.revenue_unit_item.dable',\n        ],\n        listeAr: [\n            fromB64('LmdlbWluaUxCMUFk'),\n            '.right-and-left-sponsers',\n            fromB64('YVtocmVmKj0iLmFmbGFtLmluZm8iXQ=='),\n            fromB64('YVtocmVmKj0iYm9vcmFxLm9yZyJd'),\n            fromB64('YVtocmVmKj0iZHViaXp6bGUuY29tL2FyLz91dG1fc291cmNlPSJd'),\n        ],\n        listeFr: [\n            fromB64('YVtocmVmXj0iaHR0cDovL3Byb21vLnZhZG9yLmNvbS8iXQ=='),\n            fromB64('I2FkY29udGFpbmVyX3JlY2hlcmNoZQ=='),\n            fromB64('YVtocmVmKj0id2Vib3JhbWEuZnIvZmNnaS1iaW4vIl0='),\n            '.site-pub-interstitiel',\n            'div[id^=\"crt-\"][data-criteo-id]',\n        ],\n        officialPolish: [\n            '#ceneo-placeholder-ceneo-12',\n            fromB64('W2hyZWZePSJodHRwczovL2FmZi5zZW5kaHViLnBsLyJd'),\n            fromB64('YVtocmVmXj0iaHR0cDovL2Fkdm1hbmFnZXIudGVjaGZ1bi5wbC9yZWRpcmVjdC8iXQ=='),\n            fromB64('YVtocmVmXj0iaHR0cDovL3d3dy50cml6ZXIucGwvP3V0bV9zb3VyY2UiXQ=='),\n            fromB64('ZGl2I3NrYXBpZWNfYWQ='),\n        ],\n        ro: [\n            fromB64('YVtocmVmXj0iLy9hZmZ0cmsuYWx0ZXgucm8vQ291bnRlci9DbGljayJd'),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9ibGFja2ZyaWRheXNhbGVzLnJvL3Ryay9zaG9wLyJd'),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9ldmVudC4ycGVyZm9ybWFudC5jb20vZXZlbnRzL2NsaWNrIl0='),\n            fromB64('YVtocmVmXj0iaHR0cHM6Ly9sLnByb2ZpdHNoYXJlLnJvLyJd'),\n            'a[href^=\"/url/\"]',\n        ],\n        ruAd: [\n            fromB64('YVtocmVmKj0iLy9mZWJyYXJlLnJ1LyJd'),\n            fromB64('YVtocmVmKj0iLy91dGltZy5ydS8iXQ=='),\n            fromB64('YVtocmVmKj0iOi8vY2hpa2lkaWtpLnJ1Il0='),\n            '#pgeldiz',\n            '.yandex-rtb-block',\n        ],\n        thaiAds: [\n            'a[href*=macau-uta-popup]',\n            fromB64('I2Fkcy1nb29nbGUtbWlkZGxlX3JlY3RhbmdsZS1ncm91cA=='),\n            fromB64('LmFkczMwMHM='),\n            '.bumq',\n            '.img-kosana',\n        ],\n        webAnnoyancesUltralist: [\n            '#mod-social-share-2',\n            '#social-tools',\n            fromB64('LmN0cGwtZnVsbGJhbm5lcg=='),\n            '.zergnet-recommend',\n            '.yt.btn-link.btn-md.btn',\n        ],\n    };\n}\n/**\n * The order of the returned array means nothing (it's always sorted alphabetically).\n *\n * Notice that the source is slightly unstable.\n * Safari provides a 2-taps way to disable all content blockers on a page temporarily.\n * Also content blockers can be disabled permanently for a domain, but it requires 4 taps.\n * So empty array shouldn't be treated as \"no blockers\", it should be treated as \"no signal\".\n * If you are a website owner, don't make your visitors want to disable content blockers.\n */\nasync function getDomBlockers({ debug } = {}) {\n    if (!isApplicable()) {\n        return undefined;\n    }\n    const filters = getFilters();\n    const filterNames = Object.keys(filters);\n    const allSelectors = [].concat(...filterNames.map((filterName) => filters[filterName]));\n    const blockedSelectors = await getBlockedSelectors(allSelectors);\n    if (debug) {\n        printDebug(filters, blockedSelectors);\n    }\n    const activeBlockers = filterNames.filter((filterName) => {\n        const selectors = filters[filterName];\n        const blockedCount = countTruthy(selectors.map((selector) => blockedSelectors[selector]));\n        return blockedCount > selectors.length * 0.6;\n    });\n    activeBlockers.sort();\n    return activeBlockers;\n}\nfunction isApplicable() {\n    // Safari (desktop and mobile) and all Android browsers keep content blockers in both regular and private mode\n    return isWebKit() || isAndroid();\n}\nasync function getBlockedSelectors(selectors) {\n    var _a;\n    const d = document;\n    const root = d.createElement('div');\n    const elements = new Array(selectors.length);\n    const blockedSelectors = {}; // Set() isn't used just in case somebody need older browser support\n    forceShow(root);\n    // First create all elements that can be blocked. If the DOM steps below are done in a single cycle,\n    // browser will alternate tree modification and layout reading, that is very slow.\n    for (let i = 0; i < selectors.length; ++i) {\n        const element = selectorToElement(selectors[i]);\n        if (element.tagName === 'DIALOG') {\n            element.show();\n        }\n        const holder = d.createElement('div'); // Protects from unwanted effects of `+` and `~` selectors of filters\n        forceShow(holder);\n        holder.appendChild(element);\n        root.appendChild(holder);\n        elements[i] = element;\n    }\n    // document.body can be null while the page is loading\n    while (!d.body) {\n        await wait(50);\n    }\n    d.body.appendChild(root);\n    try {\n        // Then check which of the elements are blocked\n        for (let i = 0; i < selectors.length; ++i) {\n            if (!elements[i].offsetParent) {\n                blockedSelectors[selectors[i]] = true;\n            }\n        }\n    }\n    finally {\n        // Then remove the elements\n        (_a = root.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(root);\n    }\n    return blockedSelectors;\n}\nfunction forceShow(element) {\n    element.style.setProperty('visibility', 'hidden', 'important');\n    element.style.setProperty('display', 'block', 'important');\n}\nfunction printDebug(filters, blockedSelectors) {\n    let message = 'DOM blockers debug:\\n```';\n    for (const filterName of Object.keys(filters)) {\n        message += `\\n${filterName}:`;\n        for (const selector of filters[filterName]) {\n            message += `\\n  ${blockedSelectors[selector] ? '\uD83D\uDEAB' : '\u27A1\uFE0F'} ${selector}`;\n        }\n    }\n    // console.log is ok here because it's under a debug clause\n    // eslint-disable-next-line no-console\n    console.log(`${message}\\n\\`\\`\\``);\n}\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/color-gamut\n */\nfunction getColorGamut() {\n    // rec2020 includes p3 and p3 includes srgb\n    for (const gamut of ['rec2020', 'p3', 'srgb']) {\n        if (matchMedia(`(color-gamut: ${gamut})`).matches) {\n            return gamut;\n        }\n    }\n    return undefined;\n}\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/inverted-colors\n */\nfunction areColorsInverted() {\n    if (doesMatch$5('inverted')) {\n        return true;\n    }\n    if (doesMatch$5('none')) {\n        return false;\n    }\n    return undefined;\n}\nfunction doesMatch$5(value) {\n    return matchMedia(`(inverted-colors: ${value})`).matches;\n}\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/forced-colors\n */\nfunction areColorsForced() {\n    if (doesMatch$4('active')) {\n        return true;\n    }\n    if (doesMatch$4('none')) {\n        return false;\n    }\n    return undefined;\n}\nfunction doesMatch$4(value) {\n    return matchMedia(`(forced-colors: ${value})`).matches;\n}\n\nconst maxValueToCheck = 100;\n/**\n * If the display is monochrome (e.g. black&white), the value will be \u22650 and will mean the number of bits per pixel.\n * If the display is not monochrome, the returned value will be 0.\n * If the browser doesn't support this feature, the returned value will be undefined.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/monochrome\n */\nfunction getMonochromeDepth() {\n    if (!matchMedia('(min-monochrome: 0)').matches) {\n        // The media feature isn't supported by the browser\n        return undefined;\n    }\n    // A variation of binary search algorithm can be used here.\n    // But since expected values are very small (\u226410), there is no sense in adding the complexity.\n    for (let i = 0; i <= maxValueToCheck; ++i) {\n        if (matchMedia(`(max-monochrome: ${i})`).matches) {\n            return i;\n        }\n    }\n    throw new Error('Too high value');\n}\n\n/**\n * @see https://www.w3.org/TR/mediaqueries-5/#prefers-contrast\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-contrast\n */\nfunction getContrastPreference() {\n    if (doesMatch$3('no-preference')) {\n        return 0 /* ContrastPreference.None */;\n    }\n    // The sources contradict on the keywords. Probably 'high' and 'low' will never be implemented.\n    // Need to check it when all browsers implement the feature.\n    if (doesMatch$3('high') || doesMatch$3('more')) {\n        return 1 /* ContrastPreference.More */;\n    }\n    if (doesMatch$3('low') || doesMatch$3('less')) {\n        return -1 /* ContrastPreference.Less */;\n    }\n    if (doesMatch$3('forced')) {\n        return 10 /* ContrastPreference.ForcedColors */;\n    }\n    return undefined;\n}\nfunction doesMatch$3(value) {\n    return matchMedia(`(prefers-contrast: ${value})`).matches;\n}\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion\n */\nfunction isMotionReduced() {\n    if (doesMatch$2('reduce')) {\n        return true;\n    }\n    if (doesMatch$2('no-preference')) {\n        return false;\n    }\n    return undefined;\n}\nfunction doesMatch$2(value) {\n    return matchMedia(`(prefers-reduced-motion: ${value})`).matches;\n}\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-transparency\n */\nfunction isTransparencyReduced() {\n    if (doesMatch$1('reduce')) {\n        return true;\n    }\n    if (doesMatch$1('no-preference')) {\n        return false;\n    }\n    return undefined;\n}\nfunction doesMatch$1(value) {\n    return matchMedia(`(prefers-reduced-transparency: ${value})`).matches;\n}\n\n/**\n * @see https://www.w3.org/TR/mediaqueries-5/#dynamic-range\n */\nfunction isHDR() {\n    if (doesMatch('high')) {\n        return true;\n    }\n    if (doesMatch('standard')) {\n        return false;\n    }\n    return undefined;\n}\nfunction doesMatch(value) {\n    return matchMedia(`(dynamic-range: ${value})`).matches;\n}\n\nconst M = Math; // To reduce the minified code size\nconst fallbackFn = () => 0;\n/**\n * @see https://gitlab.torproject.org/legacy/trac/-/issues/13018\n * @see https://bugzilla.mozilla.org/show_bug.cgi?id=531915\n */\nfunction getMathFingerprint() {\n    // Native operations\n    const acos = M.acos || fallbackFn;\n    const acosh = M.acosh || fallbackFn;\n    const asin = M.asin || fallbackFn;\n    const asinh = M.asinh || fallbackFn;\n    const atanh = M.atanh || fallbackFn;\n    const atan = M.atan || fallbackFn;\n    const sin = M.sin || fallbackFn;\n    const sinh = M.sinh || fallbackFn;\n    const cos = M.cos || fallbackFn;\n    const cosh = M.cosh || fallbackFn;\n    const tan = M.tan || fallbackFn;\n    const tanh = M.tanh || fallbackFn;\n    const exp = M.exp || fallbackFn;\n    const expm1 = M.expm1 || fallbackFn;\n    const log1p = M.log1p || fallbackFn;\n    // Operation polyfills\n    const powPI = (value) => M.pow(M.PI, value);\n    const acoshPf = (value) => M.log(value + M.sqrt(value * value - 1));\n    const asinhPf = (value) => M.log(value + M.sqrt(value * value + 1));\n    const atanhPf = (value) => M.log((1 + value) / (1 - value)) / 2;\n    const sinhPf = (value) => M.exp(value) - 1 / M.exp(value) / 2;\n    const coshPf = (value) => (M.exp(value) + 1 / M.exp(value)) / 2;\n    const expm1Pf = (value) => M.exp(value) - 1;\n    const tanhPf = (value) => (M.exp(2 * value) - 1) / (M.exp(2 * value) + 1);\n    const log1pPf = (value) => M.log(1 + value);\n    // Note: constant values are empirical\n    return {\n        acos: acos(0.123124234234234242),\n        acosh: acosh(1e308),\n        acoshPf: acoshPf(1e154),\n        asin: asin(0.123124234234234242),\n        asinh: asinh(1),\n        asinhPf: asinhPf(1),\n        atanh: atanh(0.5),\n        atanhPf: atanhPf(0.5),\n        atan: atan(0.5),\n        sin: sin(-1e300),\n        sinh: sinh(1),\n        sinhPf: sinhPf(1),\n        cos: cos(10.000000000123),\n        cosh: cosh(1),\n        coshPf: coshPf(1),\n        tan: tan(-1e300),\n        tanh: tanh(1),\n        tanhPf: tanhPf(1),\n        exp: exp(1),\n        expm1: expm1(1),\n        expm1Pf: expm1Pf(1),\n        log1p: log1p(10),\n        log1pPf: log1pPf(10),\n        powPI: powPI(-100),\n    };\n}\n\n/**\n * We use m or w because these two characters take up the maximum width.\n * Also there are a couple of ligatures.\n */\nconst defaultText = 'mmMwWLliI0fiflO&1';\n/**\n * Settings of text blocks to measure. The keys are random but persistent words.\n */\nconst presets = {\n    /**\n     * The default font. User can change it in desktop Chrome, desktop Firefox, IE 11,\n     * Android Chrome (but only when the size is \u2265 than the default) and Android Firefox.\n     */\n    default: [],\n    /** OS font on macOS. User can change its size and weight. Applies after Safari restart. */\n    apple: [{ font: '-apple-system-body' }],\n    /** User can change it in desktop Chrome and desktop Firefox. */\n    serif: [{ fontFamily: 'serif' }],\n    /** User can change it in desktop Chrome and desktop Firefox. */\n    sans: [{ fontFamily: 'sans-serif' }],\n    /** User can change it in desktop Chrome and desktop Firefox. */\n    mono: [{ fontFamily: 'monospace' }],\n    /**\n     * Check the smallest allowed font size. User can change it in desktop Chrome, desktop Firefox and desktop Safari.\n     * The height can be 0 in Chrome on a retina display.\n     */\n    min: [{ fontSize: '1px' }],\n    /** Tells one OS from another in desktop Chrome. */\n    system: [{ fontFamily: 'system-ui' }],\n};\n/**\n * The result is a dictionary of the width of the text samples.\n * Heights aren't included because they give no extra entropy and are unstable.\n *\n * The result is very stable in IE 11, Edge 18 and Safari 14.\n * The result changes when the OS pixel density changes in Chromium 87. The real pixel density is required to solve,\n * but seems like it's impossible: https://stackoverflow.com/q/1713771/1118709.\n * The \"min\" and the \"mono\" (only on Windows) value may change when the page is zoomed in Firefox 87.\n */\nfunction getFontPreferences() {\n    return withNaturalFonts((document, container) => {\n        const elements = {};\n        const sizes = {};\n        // First create all elements to measure. If the DOM steps below are done in a single cycle,\n        // browser will alternate tree modification and layout reading, that is very slow.\n        for (const key of Object.keys(presets)) {\n            const [style = {}, text = defaultText] = presets[key];\n            const element = document.createElement('span');\n            element.textContent = text;\n            element.style.whiteSpace = 'nowrap';\n            for (const name of Object.keys(style)) {\n                const value = style[name];\n                if (value !== undefined) {\n                    element.style[name] = value;\n                }\n            }\n            elements[key] = element;\n            container.append(document.createElement('br'), element);\n        }\n        // Then measure the created elements\n        for (const key of Object.keys(presets)) {\n            sizes[key] = elements[key].getBoundingClientRect().width;\n        }\n        return sizes;\n    });\n}\n/**\n * Creates a DOM environment that provides the most natural font available, including Android OS font.\n * Measurements of the elements are zoom-independent.\n * Don't put a content to measure inside an absolutely positioned element.\n */\nfunction withNaturalFonts(action, containerWidthPx = 4000) {\n    /*\n     * Requirements for Android Chrome to apply the system font size to a text inside an iframe:\n     * - The iframe mustn't have a `display: none;` style;\n     * - The text mustn't be positioned absolutely;\n     * - The text block must be wide enough.\n     *   2560px on some devices in portrait orientation for the biggest font size option (32px);\n     * - There must be much enough text to form a few lines (I don't know the exact numbers);\n     * - The text must have the `text-size-adjust: none` style. Otherwise the text will scale in \"Desktop site\" mode;\n     *\n     * Requirements for Android Firefox to apply the system font size to a text inside an iframe:\n     * - The iframe document must have a header: `<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />`.\n     *   The only way to set it is to use the `srcdoc` attribute of the iframe;\n     * - The iframe content must get loaded before adding extra content with JavaScript;\n     *\n     * https://example.com as the iframe target always inherits Android font settings so it can be used as a reference.\n     *\n     * Observations on how page zoom affects the measurements:\n     * - macOS Safari 11.1, 12.1, 13.1, 14.0: zoom reset + offsetWidth = 100% reliable;\n     * - macOS Safari 11.1, 12.1, 13.1, 14.0: zoom reset + getBoundingClientRect = 100% reliable;\n     * - macOS Safari 14.0: offsetWidth = 5% fluctuation;\n     * - macOS Safari 14.0: getBoundingClientRect = 5% fluctuation;\n     * - iOS Safari 9, 10, 11.0, 12.0: haven't found a way to zoom a page (pinch doesn't change layout);\n     * - iOS Safari 13.1, 14.0: zoom reset + offsetWidth = 100% reliable;\n     * - iOS Safari 13.1, 14.0: zoom reset + getBoundingClientRect = 100% reliable;\n     * - iOS Safari 14.0: offsetWidth = 100% reliable;\n     * - iOS Safari 14.0: getBoundingClientRect = 100% reliable;\n     * - Chrome 42, 65, 80, 87: zoom 1/devicePixelRatio + offsetWidth = 1px fluctuation;\n     * - Chrome 42, 65, 80, 87: zoom 1/devicePixelRatio + getBoundingClientRect = 100% reliable;\n     * - Chrome 87: offsetWidth = 1px fluctuation;\n     * - Chrome 87: getBoundingClientRect = 0.7px fluctuation;\n     * - Firefox 48, 51: offsetWidth = 10% fluctuation;\n     * - Firefox 48, 51: getBoundingClientRect = 10% fluctuation;\n     * - Firefox 52, 53, 57, 62, 66, 67, 68, 71, 75, 80, 84: offsetWidth = width 100% reliable, height 10% fluctuation;\n     * - Firefox 52, 53, 57, 62, 66, 67, 68, 71, 75, 80, 84: getBoundingClientRect = width 100% reliable, height 10%\n     *   fluctuation;\n     * - Android Chrome 86: haven't found a way to zoom a page (pinch doesn't change layout);\n     * - Android Firefox 84: font size in accessibility settings changes all the CSS sizes, but offsetWidth and\n     *   getBoundingClientRect keep measuring with regular units, so the size reflects the font size setting and doesn't\n     *   fluctuate;\n     * - IE 11, Edge 18: zoom 1/devicePixelRatio + offsetWidth = 100% reliable;\n     * - IE 11, Edge 18: zoom 1/devicePixelRatio + getBoundingClientRect = reflects the zoom level;\n     * - IE 11, Edge 18: offsetWidth = 100% reliable;\n     * - IE 11, Edge 18: getBoundingClientRect = 100% reliable;\n     */\n    return withIframe((_, iframeWindow) => {\n        const iframeDocument = iframeWindow.document;\n        const iframeBody = iframeDocument.body;\n        const bodyStyle = iframeBody.style;\n        bodyStyle.width = `${containerWidthPx}px`;\n        bodyStyle.webkitTextSizeAdjust = bodyStyle.textSizeAdjust = 'none';\n        // See the big comment above\n        if (isChromium()) {\n            iframeBody.style.zoom = `${1 / iframeWindow.devicePixelRatio}`;\n        }\n        else if (isWebKit()) {\n            iframeBody.style.zoom = 'reset';\n        }\n        // See the big comment above\n        const linesOfText = iframeDocument.createElement('div');\n        linesOfText.textContent = [...Array((containerWidthPx / 20) << 0)].map(() => 'word').join(' ');\n        iframeBody.appendChild(linesOfText);\n        return action(iframeDocument, iframeBody);\n    }, '<!doctype html><html><head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">');\n}\n\nfunction isPdfViewerEnabled() {\n    return navigator.pdfViewerEnabled;\n}\n\n/**\n * Unlike most other architectures, on x86/x86-64 when floating-point instructions\n * have no NaN arguments, but produce NaN output, the output NaN has sign bit set.\n * We use it to distinguish x86/x86-64 from other architectures, by doing subtraction\n * of two infinities (must produce NaN per IEEE 754 standard).\n *\n * See https://codebrowser.bddppq.com/pytorch/pytorch/third_party/XNNPACK/src/init.c.html#79\n */\nfunction getArchitecture() {\n    const f = new Float32Array(1);\n    const u8 = new Uint8Array(f.buffer);\n    f[0] = Infinity;\n    f[0] = f[0] - f[0];\n    return u8[3];\n}\n\n/**\n * The return type is a union instead of the enum, because it's too challenging to embed the const enum into another\n * project. Turning it into a union is a simple and an elegant solution.\n */\nfunction getApplePayState() {\n    const { ApplePaySession } = window;\n    if (typeof (ApplePaySession === null || ApplePaySession === void 0 ? void 0 : ApplePaySession.canMakePayments) !== 'function') {\n        return -1 /* ApplePayState.NoAPI */;\n    }\n    if (willPrintConsoleError()) {\n        return -3 /* ApplePayState.NotAvailableInFrame */;\n    }\n    try {\n        return ApplePaySession.canMakePayments() ? 1 /* ApplePayState.Enabled */ : 0 /* ApplePayState.Disabled */;\n    }\n    catch (error) {\n        return getStateFromError(error);\n    }\n}\n/**\n * Starting from Safari 15 calling `ApplePaySession.canMakePayments()` produces this error message when FingerprintJS\n * runs in an iframe with a cross-origin parent page, and the iframe on that page has no allow=\"payment *\" attribute:\n *   Feature policy 'Payment' check failed for element with origin 'https://example.com' and allow attribute ''.\n * This function checks whether the error message is expected.\n *\n * We check for cross-origin parents, which is prone to false-positive results. Instead, we should check for allowed\n * feature/permission, but we can't because none of these API works in Safari yet:\n *   navigator.permissions.query({ name: \u2018payment' })\n *   navigator.permissions.query({ name: \u2018payment-handler' })\n *   document.featurePolicy\n */\nconst willPrintConsoleError = isAnyParentCrossOrigin;\nfunction getStateFromError(error) {\n    // See full expected error messages in the test\n    if (error instanceof Error && error.name === 'InvalidAccessError' && /\\bfrom\\b.*\\binsecure\\b/i.test(error.message)) {\n        return -2 /* ApplePayState.NotAvailableInInsecureContext */;\n    }\n    throw error;\n}\n\n/**\n * Checks whether the Safari's Privacy Preserving Ad Measurement setting is on.\n * The setting is on when the value is not undefined.\n * A.k.a. private click measurement, privacy-preserving ad attribution.\n *\n * Unfortunately, it doesn't work in mobile Safari.\n * Probably, it will start working in mobile Safari or stop working in desktop Safari later.\n * We've found no way to detect the setting state in mobile Safari. Help wanted.\n *\n * @see https://webkit.org/blog/11529/introducing-private-click-measurement-pcm/\n * @see https://developer.apple.com/videos/play/wwdc2021/10033\n */\nfunction getPrivateClickMeasurement() {\n    var _a;\n    const link = document.createElement('a');\n    const sourceId = (_a = link.attributionSourceId) !== null && _a !== void 0 ? _a : link.attributionsourceid;\n    return sourceId === undefined ? undefined : String(sourceId);\n}\n\n/** WebGl context is not available */\nconst STATUS_NO_GL_CONTEXT = -1;\n/** WebGL context `getParameter` method is not a function */\nconst STATUS_GET_PARAMETER_NOT_A_FUNCTION = -2;\nconst validContextParameters = new Set([\n    10752, 2849, 2884, 2885, 2886, 2928, 2929, 2930, 2931, 2932, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968,\n    2978, 3024, 3042, 3088, 3089, 3106, 3107, 32773, 32777, 32777, 32823, 32824, 32936, 32937, 32938, 32939, 32968, 32969,\n    32970, 32971, 3317, 33170, 3333, 3379, 3386, 33901, 33902, 34016, 34024, 34076, 3408, 3410, 3411, 3412, 3413, 3414,\n    3415, 34467, 34816, 34817, 34818, 34819, 34877, 34921, 34930, 35660, 35661, 35724, 35738, 35739, 36003, 36004, 36005,\n    36347, 36348, 36349, 37440, 37441, 37443, 7936, 7937, 7938,\n    // SAMPLE_ALPHA_TO_COVERAGE (32926) and SAMPLE_COVERAGE (32928) are excluded because they trigger a console warning\n    // in IE, Chrome \u2264 59 and Safari \u2264 13 and give no entropy.\n]);\nconst validExtensionParams = new Set([\n    34047,\n    35723,\n    36063,\n    34852,\n    34853,\n    34854,\n    34229,\n    36392,\n    36795,\n    38449, // MAX_VIEWS_OVR\n]);\nconst shaderTypes = ['FRAGMENT_SHADER', 'VERTEX_SHADER'];\nconst precisionTypes = ['LOW_FLOAT', 'MEDIUM_FLOAT', 'HIGH_FLOAT', 'LOW_INT', 'MEDIUM_INT', 'HIGH_INT'];\nconst rendererInfoExtensionName = 'WEBGL_debug_renderer_info';\nconst polygonModeExtensionName = 'WEBGL_polygon_mode';\n/**\n * Gets the basic and simple WebGL parameters\n */\nfunction getWebGlBasics({ cache }) {\n    var _a, _b, _c, _d, _e, _f;\n    const gl = getWebGLContext(cache);\n    if (!gl) {\n        return STATUS_NO_GL_CONTEXT;\n    }\n    if (!isValidParameterGetter(gl)) {\n        return STATUS_GET_PARAMETER_NOT_A_FUNCTION;\n    }\n    const debugExtension = shouldAvoidDebugRendererInfo() ? null : gl.getExtension(rendererInfoExtensionName);\n    return {\n        version: ((_a = gl.getParameter(gl.VERSION)) === null || _a === void 0 ? void 0 : _a.toString()) || '',\n        vendor: ((_b = gl.getParameter(gl.VENDOR)) === null || _b === void 0 ? void 0 : _b.toString()) || '',\n        vendorUnmasked: debugExtension ? (_c = gl.getParameter(debugExtension.UNMASKED_VENDOR_WEBGL)) === null || _c === void 0 ? void 0 : _c.toString() : '',\n        renderer: ((_d = gl.getParameter(gl.RENDERER)) === null || _d === void 0 ? void 0 : _d.toString()) || '',\n        rendererUnmasked: debugExtension ? (_e = gl.getParameter(debugExtension.UNMASKED_RENDERER_WEBGL)) === null || _e === void 0 ? void 0 : _e.toString() : '',\n        shadingLanguageVersion: ((_f = gl.getParameter(gl.SHADING_LANGUAGE_VERSION)) === null || _f === void 0 ? void 0 : _f.toString()) || '',\n    };\n}\n/**\n * Gets the advanced and massive WebGL parameters and extensions\n */\nfunction getWebGlExtensions({ cache }) {\n    const gl = getWebGLContext(cache);\n    if (!gl) {\n        return STATUS_NO_GL_CONTEXT;\n    }\n    if (!isValidParameterGetter(gl)) {\n        return STATUS_GET_PARAMETER_NOT_A_FUNCTION;\n    }\n    const extensions = gl.getSupportedExtensions();\n    const contextAttributes = gl.getContextAttributes();\n    const unsupportedExtensions = [];\n    // Features\n    const attributes = [];\n    const parameters = [];\n    const extensionParameters = [];\n    const shaderPrecisions = [];\n    // Context attributes\n    if (contextAttributes) {\n        for (const attributeName of Object.keys(contextAttributes)) {\n            attributes.push(`${attributeName}=${contextAttributes[attributeName]}`);\n        }\n    }\n    // Context parameters\n    const constants = getConstantsFromPrototype(gl);\n    for (const constant of constants) {\n        const code = gl[constant];\n        parameters.push(`${constant}=${code}${validContextParameters.has(code) ? `=${gl.getParameter(code)}` : ''}`);\n    }\n    // Extension parameters\n    if (extensions) {\n        for (const name of extensions) {\n            if ((name === rendererInfoExtensionName && shouldAvoidDebugRendererInfo()) ||\n                (name === polygonModeExtensionName && shouldAvoidPolygonModeExtensions())) {\n                continue;\n            }\n            const extension = gl.getExtension(name);\n            if (!extension) {\n                unsupportedExtensions.push(name);\n                continue;\n            }\n            for (const constant of getConstantsFromPrototype(extension)) {\n                const code = extension[constant];\n                extensionParameters.push(`${constant}=${code}${validExtensionParams.has(code) ? `=${gl.getParameter(code)}` : ''}`);\n            }\n        }\n    }\n    // Shader precision\n    for (const shaderType of shaderTypes) {\n        for (const precisionType of precisionTypes) {\n            const shaderPrecision = getShaderPrecision(gl, shaderType, precisionType);\n            shaderPrecisions.push(`${shaderType}.${precisionType}=${shaderPrecision.join(',')}`);\n        }\n    }\n    // Postprocess\n    extensionParameters.sort();\n    parameters.sort();\n    return {\n        contextAttributes: attributes,\n        parameters: parameters,\n        shaderPrecisions: shaderPrecisions,\n        extensions: extensions,\n        extensionParameters: extensionParameters,\n        unsupportedExtensions,\n    };\n}\n/**\n * This function usually takes the most time to execute in all the sources, therefore we cache its result.\n *\n * Warning for package users:\n * This function is out of Semantic Versioning, i.e. can change unexpectedly. Usage is at your own risk.\n */\nfunction getWebGLContext(cache) {\n    if (cache.webgl) {\n        return cache.webgl.context;\n    }\n    const canvas = document.createElement('canvas');\n    let context;\n    canvas.addEventListener('webglCreateContextError', () => (context = undefined));\n    for (const type of ['webgl', 'experimental-webgl']) {\n        try {\n            context = canvas.getContext(type);\n        }\n        catch (_a) {\n            // Ok, continue\n        }\n        if (context) {\n            break;\n        }\n    }\n    cache.webgl = { context };\n    return context;\n}\n/**\n * https://developer.mozilla.org/en-US/docs/Web/API/WebGLShaderPrecisionFormat\n * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getShaderPrecisionFormat\n * https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.12\n */\nfunction getShaderPrecision(gl, shaderType, precisionType) {\n    const shaderPrecision = gl.getShaderPrecisionFormat(gl[shaderType], gl[precisionType]);\n    return shaderPrecision ? [shaderPrecision.rangeMin, shaderPrecision.rangeMax, shaderPrecision.precision] : [];\n}\nfunction getConstantsFromPrototype(obj) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const keys = Object.keys(obj.__proto__);\n    return keys.filter(isConstantLike);\n}\nfunction isConstantLike(key) {\n    return typeof key === 'string' && !key.match(/[^A-Z0-9_x]/);\n}\n/**\n * Some browsers print a console warning when the WEBGL_debug_renderer_info extension is requested.\n * JS Agent aims to avoid printing messages to console, so we avoid this extension in that browsers.\n */\nfunction shouldAvoidDebugRendererInfo() {\n    return isGecko();\n}\n/**\n * Some browsers print a console warning when the WEBGL_polygon_mode extension is requested.\n * JS Agent aims to avoid printing messages to console, so we avoid this extension in that browsers.\n */\nfunction shouldAvoidPolygonModeExtensions() {\n    return isChromium() || isWebKit();\n}\n/**\n * Some unknown browsers have no `getParameter` method\n */\nfunction isValidParameterGetter(gl) {\n    return typeof gl.getParameter === 'function';\n}\n\nfunction getAudioContextBaseLatency() {\n    // The signal emits warning in Chrome and Firefox, therefore it is enabled on Safari where it doesn't produce warning\n    // and on Android where it's less visible\n    const isAllowedPlatform = isAndroid() || isWebKit();\n    if (!isAllowedPlatform) {\n        return -2 /* SpecialFingerprint.Disabled */;\n    }\n    if (!window.AudioContext) {\n        return -1 /* SpecialFingerprint.NotSupported */;\n    }\n    const latency = new AudioContext().baseLatency;\n    if (latency === null || latency === undefined) {\n        return -1 /* SpecialFingerprint.NotSupported */;\n    }\n    if (!isFinite(latency)) {\n        return -3 /* SpecialFingerprint.NotFinite */;\n    }\n    return latency;\n}\n\n/**\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/resolvedOptions\n *\n * The return type is a union instead of a const enum due to the difficulty of embedding const enums in other projects.\n * This makes integration simpler and more elegant.\n */\nfunction getDateTimeLocale() {\n    if (!window.Intl) {\n        return -1 /* Status.IntlAPINotSupported */;\n    }\n    const DateTimeFormat = window.Intl.DateTimeFormat;\n    if (!DateTimeFormat) {\n        return -2 /* Status.DateTimeFormatNotSupported */;\n    }\n    const locale = DateTimeFormat().resolvedOptions().locale;\n    if (!locale && locale !== '') {\n        return -3 /* Status.LocaleNotAvailable */;\n    }\n    return locale;\n}\n\n/**\n * The list of entropy sources used to make visitor identifiers.\n *\n * This value isn't restricted by Semantic Versioning, i.e. it may be changed without bumping minor or major version of\n * this package.\n *\n * Note: Rollup and Webpack are smart enough to remove unused properties of this object during tree-shaking, so there is\n * no need to export the sources individually.\n */\nconst sources = {\n    // READ FIRST:\n    // See https://github.com/fingerprintjs/fingerprintjs/blob/master/contributing.md#how-to-add-an-entropy-source\n    // to learn how entropy source works and how to make your own.\n    // The sources run in this exact order.\n    // The asynchronous sources are at the start to run in parallel with other sources.\n    fonts: getFonts,\n    domBlockers: getDomBlockers,\n    fontPreferences: getFontPreferences,\n    audio: getAudioFingerprint,\n    screenFrame: getScreenFrame,\n    canvas: getCanvasFingerprint,\n    osCpu: getOsCpu,\n    languages: getLanguages,\n    colorDepth: getColorDepth,\n    deviceMemory: getDeviceMemory,\n    screenResolution: getScreenResolution,\n    hardwareConcurrency: getHardwareConcurrency,\n    timezone: getTimezone,\n    sessionStorage: getSessionStorage,\n    localStorage: getLocalStorage,\n    indexedDB: getIndexedDB,\n    openDatabase: getOpenDatabase,\n    cpuClass: getCpuClass,\n    platform: getPlatform,\n    plugins: getPlugins,\n    touchSupport: getTouchSupport,\n    vendor: getVendor,\n    vendorFlavors: getVendorFlavors,\n    cookiesEnabled: areCookiesEnabled,\n    colorGamut: getColorGamut,\n    invertedColors: areColorsInverted,\n    forcedColors: areColorsForced,\n    monochrome: getMonochromeDepth,\n    contrast: getContrastPreference,\n    reducedMotion: isMotionReduced,\n    reducedTransparency: isTransparencyReduced,\n    hdr: isHDR,\n    math: getMathFingerprint,\n    pdfViewerEnabled: isPdfViewerEnabled,\n    architecture: getArchitecture,\n    applePay: getApplePayState,\n    privateClickMeasurement: getPrivateClickMeasurement,\n    audioBaseLatency: getAudioContextBaseLatency,\n    dateTimeLocale: getDateTimeLocale,\n    // Some sources can affect other sources (e.g. WebGL can affect canvas), so it's important to run these sources\n    // after other sources.\n    webGlBasics: getWebGlBasics,\n    webGlExtensions: getWebGlExtensions,\n};\n/**\n * Loads the built-in entropy sources.\n * Returns a function that collects the entropy components to make the visitor identifier.\n */\nfunction loadBuiltinSources(options) {\n    return loadSources(sources, options, []);\n}\n\nconst commentTemplate = '$ if upgrade to Pro: https://fpjs.dev/pro';\nfunction getConfidence(components) {\n    const openConfidenceScore = getOpenConfidenceScore(components);\n    const proConfidenceScore = deriveProConfidenceScore(openConfidenceScore);\n    return { score: openConfidenceScore, comment: commentTemplate.replace(/\\$/g, `${proConfidenceScore}`) };\n}\nfunction getOpenConfidenceScore(components) {\n    // In order to calculate the true probability of the visitor identifier being correct, we need to know the number of\n    // website visitors (the higher the number, the less the probability because the fingerprint entropy is limited).\n    // JS agent doesn't know the number of visitors, so we can only do an approximate assessment.\n    if (isAndroid()) {\n        return 0.4;\n    }\n    // Safari (mobile and desktop)\n    if (isWebKit()) {\n        return isDesktopWebKit() && !(isWebKit616OrNewer() && isSafariWebKit()) ? 0.5 : 0.3;\n    }\n    const platform = 'value' in components.platform ? components.platform.value : '';\n    // Windows\n    if (/^Win/.test(platform)) {\n        // The score is greater than on macOS because of the higher variety of devices running Windows.\n        // Chrome provides more entropy than Firefox according too\n        // https://netmarketshare.com/browser-market-share.aspx?options=%7B%22filter%22%3A%7B%22%24and%22%3A%5B%7B%22platform%22%3A%7B%22%24in%22%3A%5B%22Windows%22%5D%7D%7D%5D%7D%2C%22dateLabel%22%3A%22Trend%22%2C%22attributes%22%3A%22share%22%2C%22group%22%3A%22browser%22%2C%22sort%22%3A%7B%22share%22%3A-1%7D%2C%22id%22%3A%22browsersDesktop%22%2C%22dateInterval%22%3A%22Monthly%22%2C%22dateStart%22%3A%222019-11%22%2C%22dateEnd%22%3A%222020-10%22%2C%22segments%22%3A%22-1000%22%7D\n        // So we assign the same score to them.\n        return 0.6;\n    }\n    // macOS\n    if (/^Mac/.test(platform)) {\n        // Chrome provides more entropy than Safari and Safari provides more entropy than Firefox.\n        // Chrome is more popular than Safari and Safari is more popular than Firefox according to\n        // https://netmarketshare.com/browser-market-share.aspx?options=%7B%22filter%22%3A%7B%22%24and%22%3A%5B%7B%22platform%22%3A%7B%22%24in%22%3A%5B%22Mac%20OS%22%5D%7D%7D%5D%7D%2C%22dateLabel%22%3A%22Trend%22%2C%22attributes%22%3A%22share%22%2C%22group%22%3A%22browser%22%2C%22sort%22%3A%7B%22share%22%3A-1%7D%2C%22id%22%3A%22browsersDesktop%22%2C%22dateInterval%22%3A%22Monthly%22%2C%22dateStart%22%3A%222019-11%22%2C%22dateEnd%22%3A%222020-10%22%2C%22segments%22%3A%22-1000%22%7D\n        // So we assign the same score to them.\n        return 0.5;\n    }\n    // Another platform, e.g. a desktop Linux. It's rare, so it should be pretty unique.\n    return 0.7;\n}\nfunction deriveProConfidenceScore(openConfidenceScore) {\n    return round(0.99 + 0.01 * openConfidenceScore, 0.0001);\n}\n\nfunction componentsToCanonicalString(components) {\n    let result = '';\n    for (const componentKey of Object.keys(components).sort()) {\n        const component = components[componentKey];\n        const value = 'error' in component ? 'error' : JSON.stringify(component.value);\n        result += `${result ? '|' : ''}${componentKey.replace(/([:|\\\\])/g, '\\\\$1')}:${value}`;\n    }\n    return result;\n}\nfunction componentsToDebugString(components) {\n    return JSON.stringify(components, (_key, value) => {\n        if (value instanceof Error) {\n            return errorToObject(value);\n        }\n        return value;\n    }, 2);\n}\nfunction hashComponents(components) {\n    return x64hash128(componentsToCanonicalString(components));\n}\n/**\n * Makes a GetResult implementation that calculates the visitor id hash on demand.\n * Designed for optimisation.\n */\nfunction makeLazyGetResult(components) {\n    let visitorIdCache;\n    // This function runs very fast, so there is no need to make it lazy\n    const confidence = getConfidence(components);\n    // A plain class isn't used because its getters and setters aren't enumerable.\n    return {\n        get visitorId() {\n            if (visitorIdCache === undefined) {\n                visitorIdCache = hashComponents(this.components);\n            }\n            return visitorIdCache;\n        },\n        set visitorId(visitorId) {\n            visitorIdCache = visitorId;\n        },\n        confidence,\n        components,\n        version,\n    };\n}\n/**\n * A delay is required to ensure consistent entropy components.\n * See https://github.com/fingerprintjs/fingerprintjs/issues/254\n * and https://github.com/fingerprintjs/fingerprintjs/issues/307\n * and https://github.com/fingerprintjs/fingerprintjs/commit/945633e7c5f67ae38eb0fea37349712f0e669b18\n */\nfunction prepareForSources(delayFallback = 50) {\n    // A proper deadline is unknown. Let it be twice the fallback timeout so that both cases have the same average time.\n    return requestIdleCallbackIfAvailable(delayFallback, delayFallback * 2);\n}\n/**\n * The function isn't exported from the index file to not allow to call it without `load()`.\n * The hiding gives more freedom for future non-breaking updates.\n *\n * A factory function is used instead of a class to shorten the attribute names in the minified code.\n * Native private class fields could've been used, but TypeScript doesn't allow them with `\"target\": \"es5\"`.\n */\nfunction makeAgent(getComponents, debug) {\n    const creationTime = Date.now();\n    return {\n        async get(options) {\n            const startTime = Date.now();\n            const components = await getComponents();\n            const result = makeLazyGetResult(components);\n            if (debug || (options === null || options === void 0 ? void 0 : options.debug)) {\n                // console.log is ok here because it's under a debug clause\n                // eslint-disable-next-line no-console\n                console.log(`Copy the text below to get the debug data:\n\n\\`\\`\\`\nversion: ${result.version}\nuserAgent: ${navigator.userAgent}\ntimeBetweenLoadAndGet: ${startTime - creationTime}\nvisitorId: ${result.visitorId}\ncomponents: ${componentsToDebugString(components)}\n\\`\\`\\``);\n            }\n            return result;\n        },\n    };\n}\n/**\n * Sends an unpersonalized AJAX request to collect installation statistics\n */\nfunction monitor() {\n    // The FingerprintJS CDN (https://github.com/fingerprintjs/cdn) replaces `window.__fpjs_d_m` with `true`\n    if (window.__fpjs_d_m || Math.random() >= 0.001) {\n        return;\n    }\n    try {\n        const request = new XMLHttpRequest();\n        request.open('get', `https://m1.openfpcdn.io/fingerprintjs/v${version}/npm-monitoring`, true);\n        request.send();\n    }\n    catch (error) {\n        // console.error is ok here because it's an unexpected error handler\n        // eslint-disable-next-line no-console\n        console.error(error);\n    }\n}\n/**\n * Builds an instance of Agent and waits a delay required for a proper operation.\n */\nasync function load(options = {}) {\n    var _a;\n    if ((_a = options.monitoring) !== null && _a !== void 0 ? _a : true) {\n        monitor();\n    }\n    const { delayFallback, debug } = options;\n    await prepareForSources(delayFallback);\n    const getComponents = loadBuiltinSources({ cache: {}, debug });\n    return makeAgent(getComponents, debug);\n}\n\n// The default export is a syntax sugar (`import * as FP from '...' \u2192 import FP from '...'`).\n// It should contain all the public exported values.\nvar index = { load, hashComponents, componentsToDebugString };\n// The exports below are for private usage. They may change unexpectedly. Use them at your own risk.\n/** Not documented, out of Semantic Versioning, usage is at your own risk */\nconst murmurX64Hash128 = x64hash128;\n\nexports.componentsToDebugString = componentsToDebugString;\nexports.default = index;\nexports.getFullscreenElement = getFullscreenElement;\nexports.getUnstableAudioFingerprint = getUnstableAudioFingerprint;\nexports.getUnstableCanvasFingerprint = getUnstableCanvasFingerprint;\nexports.getUnstableScreenFrame = getUnstableScreenFrame;\nexports.getUnstableScreenResolution = getUnstableScreenResolution;\nexports.getWebGLContext = getWebGLContext;\nexports.hashComponents = hashComponents;\nexports.isAndroid = isAndroid;\nexports.isChromium = isChromium;\nexports.isDesktopWebKit = isDesktopWebKit;\nexports.isEdgeHTML = isEdgeHTML;\nexports.isGecko = isGecko;\nexports.isSamsungInternet = isSamsungInternet;\nexports.isTrident = isTrident;\nexports.isWebKit = isWebKit;\nexports.load = load;\nexports.loadSources = loadSources;\nexports.murmurX64Hash128 = murmurX64Hash128;\nexports.prepareForSources = prepareForSources;\nexports.sources = sources;\nexports.transformSource = transformSource;\nexports.withIframe = withIframe;\n", "'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nexports.getDefaultsFromPostinstall = () => (undefined);", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.\n */\n\nexport const CONSTANTS = {\n  /**\n   * @define {boolean} Whether this is the client Node.js SDK.\n   */\n  NODE_CLIENT: false,\n  /**\n   * @define {boolean} Whether this is the Admin Node.js SDK.\n   */\n  NODE_ADMIN: false,\n\n  /**\n   * Firebase SDK Version\n   */\n  SDK_VERSION: '${JSCORE_VERSION}'\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\n\n/**\n * Throws an error if the provided assertion is falsy\n */\nexport const assert = function (assertion: unknown, message: string): void {\n  if (!assertion) {\n    throw assertionError(message);\n  }\n};\n\n/**\n * Returns an Error object suitable for throwing.\n */\nexport const assertionError = function (message: string): Error {\n  return new Error(\n    'Firebase Database (' +\n      CONSTANTS.SDK_VERSION +\n      ') INTERNAL ASSERT FAILED: ' +\n      message\n  );\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst stringToByteArray = function (str: string): number[] {\n  // TODO(user): Use native implementations if/when available\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (\n      (c & 0xfc00) === 0xd800 &&\n      i + 1 < str.length &&\n      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00\n    ) {\n      // Surrogate Pair\n      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes: number[]): string {\n  // TODO(user): Use native implementations if/when available\n  const out: string[] = [];\n  let pos = 0,\n    c = 0;\n  while (pos < bytes.length) {\n    const c1 = bytes[pos++];\n    if (c1 < 128) {\n      out[c++] = String.fromCharCode(c1);\n    } else if (c1 > 191 && c1 < 224) {\n      const c2 = bytes[pos++];\n      out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\n    } else if (c1 > 239 && c1 < 365) {\n      // Surrogate Pair\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      const c4 = bytes[pos++];\n      const u =\n        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n        0x10000;\n      out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n    } else {\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      out[c++] = String.fromCharCode(\n        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)\n      );\n    }\n  }\n  return out.join('');\n};\n\ninterface Base64 {\n  byteToCharMap_: { [key: number]: string } | null;\n  charToByteMap_: { [key: string]: number } | null;\n  byteToCharMapWebSafe_: { [key: number]: string } | null;\n  charToByteMapWebSafe_: { [key: string]: number } | null;\n  ENCODED_VALS_BASE: string;\n  readonly ENCODED_VALS: string;\n  readonly ENCODED_VALS_WEBSAFE: string;\n  HAS_NATIVE_SUPPORT: boolean;\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string;\n  encodeString(input: string, webSafe?: boolean): string;\n  decodeString(input: string, webSafe: boolean): string;\n  decodeStringToByteArray(input: string, webSafe: boolean): number[];\n  init_(): void;\n}\n\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\n// TODO(dlarocque): Define this as a class, since we no longer target ES5.\nexport const base64: Base64 = {\n  /**\n   * Maps bytes to characters.\n   */\n  byteToCharMap_: null,\n\n  /**\n   * Maps characters to bytes.\n   */\n  charToByteMap_: null,\n\n  /**\n   * Maps bytes to websafe characters.\n   * @private\n   */\n  byteToCharMapWebSafe_: null,\n\n  /**\n   * Maps websafe characters to bytes.\n   * @private\n   */\n  charToByteMapWebSafe_: null,\n\n  /**\n   * Our default alphabet, shared between\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n   */\n  ENCODED_VALS_BASE:\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n\n  /**\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n\n  /**\n   * Our websafe alphabet.\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n\n  /**\n   * Whether this browser supports the atob and btoa functions. This extension\n   * started at Mozilla but is now implemented by many browsers. We use the\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\n   * but still allowing the standard per-browser compilations.\n   *\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n\n  /**\n   * Base64-encode an array of bytes.\n   *\n   * @param input An array of bytes (numbers with\n   *     value in [0, 255]) to encode.\n   * @param webSafe Boolean indicating we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n\n    this.init_();\n\n    const byteToCharMap = webSafe\n      ? this.byteToCharMapWebSafe_!\n      : this.byteToCharMap_!;\n\n    const output = [];\n\n    for (let i = 0; i < input.length; i += 3) {\n      const byte1 = input[i];\n      const haveByte2 = i + 1 < input.length;\n      const byte2 = haveByte2 ? input[i + 1] : 0;\n      const haveByte3 = i + 2 < input.length;\n      const byte3 = haveByte3 ? input[i + 2] : 0;\n\n      const outByte1 = byte1 >> 2;\n      const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\n      let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\n      let outByte4 = byte3 & 0x3f;\n\n      if (!haveByte3) {\n        outByte4 = 64;\n\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n\n      output.push(\n        byteToCharMap[outByte1],\n        byteToCharMap[outByte2],\n        byteToCharMap[outByte3],\n        byteToCharMap[outByte4]\n      );\n    }\n\n    return output.join('');\n  },\n\n  /**\n   * Base64-encode a string.\n   *\n   * @param input A string to encode.\n   * @param webSafe If true, we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeString(input: string, webSafe?: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return btoa(input);\n    }\n    return this.encodeByteArray(stringToByteArray(input), webSafe);\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * @param input to decode.\n   * @param webSafe True if we should use the\n   *     alternative alphabet.\n   * @return string representing the decoded value.\n   */\n  decodeString(input: string, webSafe: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return atob(input);\n    }\n    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * In base-64 decoding, groups of four characters are converted into three\n   * bytes.  If the encoder did not apply padding, the input length may not\n   * be a multiple of 4.\n   *\n   * In this case, the last group will have fewer than 4 characters, and\n   * padding will be inferred.  If the group has one or two characters, it decodes\n   * to one byte.  If the group has three characters, it decodes to two bytes.\n   *\n   * @param input Input to decode.\n   * @param webSafe True if we should use the web-safe alphabet.\n   * @return bytes representing the decoded value.\n   */\n  decodeStringToByteArray(input: string, webSafe: boolean): number[] {\n    this.init_();\n\n    const charToByteMap = webSafe\n      ? this.charToByteMapWebSafe_!\n      : this.charToByteMap_!;\n\n    const output: number[] = [];\n\n    for (let i = 0; i < input.length; ) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw new DecodeBase64StringError();\n      }\n\n      const outByte1 = (byte1 << 2) | (byte2 >> 4);\n      output.push(outByte1);\n\n      if (byte3 !== 64) {\n        const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n        output.push(outByte2);\n\n        if (byte4 !== 64) {\n          const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n\n    return output;\n  },\n\n  /**\n   * Lazy static initialization function. Called before\n   * accessing any of the static map variables.\n   * @private\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n\n      // We want quick mappings back and forth, so we precompute two maps.\n      for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n        this.charToByteMap_[this.byteToCharMap_[i]] = i;\n        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n\n        // Be forgiving when decoding and correctly decode both encodings.\n        if (i >= this.ENCODED_VALS_BASE.length) {\n          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n        }\n      }\n    }\n  }\n};\n\n/**\n * An error encountered while decoding base64 string.\n */\nexport class DecodeBase64StringError extends Error {\n  readonly name = 'DecodeBase64StringError';\n}\n\n/**\n * URL-safe base64 encoding\n */\nexport const base64Encode = function (str: string): string {\n  const utf8Bytes = stringToByteArray(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n\n/**\n * URL-safe base64 encoding (without \".\" padding in the end).\n * e.g. Used in JSON Web Token (JWT) parts.\n */\nexport const base64urlEncodeWithoutPadding = function (str: string): string {\n  // Use base64url encoding and remove padding in the end (dot characters).\n  return base64Encode(str).replace(/\\./g, '');\n};\n\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nexport const base64Decode = function (str: string): string | null {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Do a deep-copy of basic JavaScript Objects or Arrays.\n */\nexport function deepCopy<T>(value: T): T {\n  return deepExtend(undefined, value) as T;\n}\n\n/**\n * Copy properties from source to target (recursively allows extension\n * of Objects and Arrays).  Scalar values in the target are over-written.\n * If target is undefined, an object of the appropriate type will be created\n * (and returned).\n *\n * We recursively copy all child properties of plain Objects in the source- so\n * that namespace- like dictionaries are merged.\n *\n * Note that the target can be a function, in which case the properties in\n * the source Object are copied onto it as static properties of the Function.\n *\n * Note: we don't merge __proto__ to prevent prototype pollution\n */\nexport function deepExtend(target: unknown, source: unknown): unknown {\n  if (!(source instanceof Object)) {\n    return source;\n  }\n\n  switch (source.constructor) {\n    case Date:\n      // Treat Dates like scalars; if the target date object had any child\n      // properties - they will be lost!\n      const dateValue = source as Date;\n      return new Date(dateValue.getTime());\n\n    case Object:\n      if (target === undefined) {\n        target = {};\n      }\n      break;\n    case Array:\n      // Always copy the array source and overwrite the target.\n      target = [];\n      break;\n\n    default:\n      // Not a plain Object - treat it as a scalar.\n      return source;\n  }\n\n  for (const prop in source) {\n    // use isValidKey to guard against prototype pollution. See https://snyk.io/vuln/SNYK-JS-LODASH-450202\n    if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {\n      continue;\n    }\n    (target as Record<string, unknown>)[prop] = deepExtend(\n      (target as Record<string, unknown>)[prop],\n      (source as Record<string, unknown>)[prop]\n    );\n  }\n\n  return target;\n}\n\nfunction isValidKey(key: string): boolean {\n  return key !== '__proto__';\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Polyfill for `globalThis` object.\n * @returns the `globalThis` object for the given environment.\n * @public\n */\nexport function getGlobal(): typeof globalThis {\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('Unable to locate global object.');\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64Decode } from './crypt';\nimport { getGlobal } from './global';\nimport { getDefaultsFromPostinstall } from './postinstall';\n\n/**\n * Keys for experimental properties on the `FirebaseDefaults` object.\n * @public\n */\nexport type ExperimentalKey = 'authTokenSyncURL' | 'authIdTokenMaxAge';\n\n/**\n * An object that can be injected into the environment as __FIREBASE_DEFAULTS__,\n * either as a property of globalThis, a shell environment variable, or a\n * cookie.\n *\n * This object can be used to automatically configure and initialize\n * a Firebase app as well as any emulators.\n *\n * @public\n */\nexport interface FirebaseDefaults {\n  config?: Record<string, string>;\n  emulatorHosts?: Record<string, string>;\n  _authTokenSyncURL?: string;\n  _authIdTokenMaxAge?: number;\n  /**\n   * Override Firebase's runtime environment detection and\n   * force the SDK to act as if it were in the specified environment.\n   */\n  forceEnvironment?: 'browser' | 'node';\n  [key: string]: unknown;\n}\n\ndeclare global {\n  // Need `var` for this to work.\n  // eslint-disable-next-line no-var\n  var __FIREBASE_DEFAULTS__: FirebaseDefaults | undefined;\n}\n\nconst getDefaultsFromGlobal = (): FirebaseDefaults | undefined =>\n  getGlobal().__FIREBASE_DEFAULTS__;\n\n/**\n * Attempt to read defaults from a JSON string provided to\n * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in\n * process(.)env(.)__FIREBASE_DEFAULTS_PATH__\n * The dots are in parens because certain compilers (Vite?) cannot\n * handle seeing that variable in comments.\n * See https://github.com/firebase/firebase-js-sdk/issues/6838\n */\nconst getDefaultsFromEnvVariable = (): FirebaseDefaults | undefined => {\n  if (typeof process === 'undefined' || typeof process.env === 'undefined') {\n    return;\n  }\n  const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;\n  if (defaultsJsonString) {\n    return JSON.parse(defaultsJsonString);\n  }\n};\n\nconst getDefaultsFromCookie = (): FirebaseDefaults | undefined => {\n  if (typeof document === 'undefined') {\n    return;\n  }\n  let match;\n  try {\n    match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);\n  } catch (e) {\n    // Some environments such as Angular Universal SSR have a\n    // `document` object but error on accessing `document.cookie`.\n    return;\n  }\n  const decoded = match && base64Decode(match[1]);\n  return decoded && JSON.parse(decoded);\n};\n\n/**\n * Get the __FIREBASE_DEFAULTS__ object. It checks in order:\n * (1) if such an object exists as a property of `globalThis`\n * (2) if such an object was provided on a shell environment variable\n * (3) if such an object exists in a cookie\n * @public\n */\nexport const getDefaults = (): FirebaseDefaults | undefined => {\n  try {\n    return (\n      getDefaultsFromPostinstall() ||\n      getDefaultsFromGlobal() ||\n      getDefaultsFromEnvVariable() ||\n      getDefaultsFromCookie()\n    );\n  } catch (e) {\n    /**\n     * Catch-all for being unable to get __FIREBASE_DEFAULTS__ due\n     * to any environment case we have not accounted for. Log to\n     * info instead of swallowing so we can find these unknown cases\n     * and add paths for them if needed.\n     */\n    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);\n    return;\n  }\n};\n\n/**\n * Returns emulator host stored in the __FIREBASE_DEFAULTS__ object\n * for the given product.\n * @returns a URL host formatted like `127.0.0.1:9999` or `[::1]:4000` if available\n * @public\n */\nexport const getDefaultEmulatorHost = (\n  productName: string\n): string | undefined => getDefaults()?.emulatorHosts?.[productName];\n\n/**\n * Returns emulator hostname and port stored in the __FIREBASE_DEFAULTS__ object\n * for the given product.\n * @returns a pair of hostname and port like `[\"::1\", 4000]` if available\n * @public\n */\nexport const getDefaultEmulatorHostnameAndPort = (\n  productName: string\n): [hostname: string, port: number] | undefined => {\n  const host = getDefaultEmulatorHost(productName);\n  if (!host) {\n    return undefined;\n  }\n  const separatorIndex = host.lastIndexOf(':'); // Finding the last since IPv6 addr also has colons.\n  if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {\n    throw new Error(`Invalid host ${host} with no separate hostname and port!`);\n  }\n  // eslint-disable-next-line no-restricted-globals\n  const port = parseInt(host.substring(separatorIndex + 1), 10);\n  if (host[0] === '[') {\n    // Bracket-quoted `[ipv6addr]:port` => return \"ipv6addr\" (without brackets).\n    return [host.substring(1, separatorIndex - 1), port];\n  } else {\n    return [host.substring(0, separatorIndex), port];\n  }\n};\n\n/**\n * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.\n * @public\n */\nexport const getDefaultAppConfig = (): Record<string, string> | undefined =>\n  getDefaults()?.config;\n\n/**\n * Returns an experimental setting on the __FIREBASE_DEFAULTS__ object (properties\n * prefixed by \"_\")\n * @public\n */\nexport const getExperimentalSetting = <T extends ExperimentalKey>(\n  name: T\n): FirebaseDefaults[`_${T}`] =>\n  getDefaults()?.[`_${name}`] as FirebaseDefaults[`_${T}`];\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport class Deferred<R> {\n  promise: Promise<R>;\n  reject: (value?: unknown) => void = () => {};\n  resolve: (value?: unknown) => void = () => {};\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve as (value?: unknown) => void;\n      this.reject = reject as (value?: unknown) => void;\n    });\n  }\n\n  /**\n   * Our API internals are not promisified and cannot because our callback APIs have subtle expectations around\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\n   */\n  wrapCallback(\n    callback?: (error?: unknown, value?: unknown) => void\n  ): (error: unknown, value?: unknown) => void {\n    return (error, value?) => {\n      if (error) {\n        this.reject(error);\n      } else {\n        this.resolve(value);\n      }\n      if (typeof callback === 'function') {\n        // Attaching noop handler just in case developer wasn't expecting\n        // promises\n        this.promise.catch(() => {});\n\n        // Some of our callbacks don't expect a value and our own tests\n        // assert that the parameter length is 1\n        if (callback.length === 1) {\n          callback(error);\n        } else {\n          callback(error, value);\n        }\n      }\n    };\n  }\n}\n", "/**\n * @license\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Checks whether host is a cloud workstation or not.\n * @public\n */\nexport function isCloudWorkstation(url: string): boolean {\n  // `isCloudWorkstation` is called without protocol in certain connect*Emulator functions\n  // In HTTP request builders, it's called with the protocol.\n  // If called with protocol prefix, it's a valid URL, so we extract the hostname\n  // If called without, we assume the string is the hostname.\n  try {\n    const host =\n      url.startsWith('http://') || url.startsWith('https://')\n        ? new URL(url).hostname\n        : url;\n    return host.endsWith('.cloudworkstations.dev');\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Makes a fetch request to the given server.\n * Mostly used for forwarding cookies in Firebase Studio.\n * @public\n */\nexport async function pingServer(endpoint: string): Promise<boolean> {\n  const result = await fetch(endpoint, {\n    credentials: 'include'\n  });\n  return result.ok;\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64urlEncodeWithoutPadding } from './crypt';\nimport { isCloudWorkstation } from './url';\n\n// Firebase Auth tokens contain snake_case claims following the JWT standard / convention.\n/* eslint-disable camelcase */\n\nexport type FirebaseSignInProvider =\n  | 'custom'\n  | 'email'\n  | 'password'\n  | 'phone'\n  | 'anonymous'\n  | 'google.com'\n  | 'facebook.com'\n  | 'github.com'\n  | 'twitter.com'\n  | 'microsoft.com'\n  | 'apple.com';\n\ninterface FirebaseIdToken {\n  // Always set to https://securetoken.google.com/PROJECT_ID\n  iss: string;\n\n  // Always set to PROJECT_ID\n  aud: string;\n\n  // The user's unique ID\n  sub: string;\n\n  // The token issue time, in seconds since epoch\n  iat: number;\n\n  // The token expiry time, normally 'iat' + 3600\n  exp: number;\n\n  // The user's unique ID. Must be equal to 'sub'\n  user_id: string;\n\n  // The time the user authenticated, normally 'iat'\n  auth_time: number;\n\n  // The sign in provider, only set when the provider is 'anonymous'\n  provider_id?: 'anonymous';\n\n  // The user's primary email\n  email?: string;\n\n  // The user's email verification status\n  email_verified?: boolean;\n\n  // The user's primary phone number\n  phone_number?: string;\n\n  // The user's display name\n  name?: string;\n\n  // The user's profile photo URL\n  picture?: string;\n\n  // Information on all identities linked to this user\n  firebase: {\n    // The primary sign-in provider\n    sign_in_provider: FirebaseSignInProvider;\n\n    // A map of providers to the user's list of unique identifiers from\n    // each provider\n    identities?: { [provider in FirebaseSignInProvider]?: string[] };\n  };\n\n  // Custom claims set by the developer\n  [claim: string]: unknown;\n\n  uid?: never; // Try to catch a common mistake of \"uid\" (should be \"sub\" instead).\n}\n\nexport type EmulatorMockTokenOptions = ({ user_id: string } | { sub: string }) &\n  Partial<FirebaseIdToken>;\n\nexport function createMockUserToken(\n  token: EmulatorMockTokenOptions,\n  projectId?: string\n): string {\n  if (token.uid) {\n    throw new Error(\n      'The \"uid\" field is no longer supported by mockUserToken. Please use \"sub\" instead for Firebase Auth User ID.'\n    );\n  }\n  // Unsecured JWTs use \"none\" as the algorithm.\n  const header = {\n    alg: 'none',\n    type: 'JWT'\n  };\n\n  const project = projectId || 'demo-project';\n  const iat = token.iat || 0;\n  const sub = token.sub || token.user_id;\n  if (!sub) {\n    throw new Error(\"mockUserToken must contain 'sub' or 'user_id' field!\");\n  }\n\n  const payload: FirebaseIdToken = {\n    // Set all required fields to decent defaults\n    iss: `https://securetoken.google.com/${project}`,\n    aud: project,\n    iat,\n    exp: iat + 3600,\n    auth_time: iat,\n    sub,\n    user_id: sub,\n    firebase: {\n      sign_in_provider: 'custom',\n      identities: {}\n    },\n\n    // Override with user options\n    ...token\n  };\n\n  // Unsecured JWTs use the empty string as a signature.\n  const signature = '';\n  return [\n    base64urlEncodeWithoutPadding(JSON.stringify(header)),\n    base64urlEncodeWithoutPadding(JSON.stringify(payload)),\n    signature\n  ].join('.');\n}\n\ninterface EmulatorStatusMap {\n  [name: string]: boolean;\n}\nconst emulatorStatus: EmulatorStatusMap = {};\n\ninterface EmulatorSummary {\n  prod: string[];\n  emulator: string[];\n}\n\n// Checks whether any products are running on an emulator\nfunction getEmulatorSummary(): EmulatorSummary {\n  const summary: EmulatorSummary = {\n    prod: [],\n    emulator: []\n  };\n  for (const key of Object.keys(emulatorStatus)) {\n    if (emulatorStatus[key]) {\n      summary.emulator.push(key);\n    } else {\n      summary.prod.push(key);\n    }\n  }\n  return summary;\n}\n\nfunction getOrCreateEl(id: string): { created: boolean; element: HTMLElement } {\n  let parentDiv = document.getElementById(id);\n  let created = false;\n  if (!parentDiv) {\n    parentDiv = document.createElement('div');\n    parentDiv.setAttribute('id', id);\n    created = true;\n  }\n  return { created, element: parentDiv };\n}\n\nlet previouslyDismissed = false;\n/**\n * Updates Emulator Banner. Primarily used for Firebase Studio\n * @param name\n * @param isRunningEmulator\n * @public\n */\nexport function updateEmulatorBanner(\n  name: string,\n  isRunningEmulator: boolean\n): void {\n  if (\n    typeof window === 'undefined' ||\n    typeof document === 'undefined' ||\n    !isCloudWorkstation(window.location.host) ||\n    emulatorStatus[name] === isRunningEmulator ||\n    emulatorStatus[name] || // If already set to use emulator, can't go back to prod.\n    previouslyDismissed\n  ) {\n    return;\n  }\n\n  emulatorStatus[name] = isRunningEmulator;\n\n  function prefixedId(id: string): string {\n    return `__firebase__banner__${id}`;\n  }\n  const bannerId = '__firebase__banner';\n  const summary = getEmulatorSummary();\n  const showError = summary.prod.length > 0;\n\n  function tearDown(): void {\n    const element = document.getElementById(bannerId);\n    if (element) {\n      element.remove();\n    }\n  }\n\n  function setupBannerStyles(bannerEl: HTMLElement): void {\n    bannerEl.style.display = 'flex';\n    bannerEl.style.background = '#7faaf0';\n    bannerEl.style.position = 'fixed';\n    bannerEl.style.bottom = '5px';\n    bannerEl.style.left = '5px';\n    bannerEl.style.padding = '.5em';\n    bannerEl.style.borderRadius = '5px';\n    bannerEl.style.alignItems = 'center';\n  }\n\n  function setupIconStyles(prependIcon: SVGElement, iconId: string): void {\n    prependIcon.setAttribute('width', '24');\n    prependIcon.setAttribute('id', iconId);\n    prependIcon.setAttribute('height', '24');\n    prependIcon.setAttribute('viewBox', '0 0 24 24');\n    prependIcon.setAttribute('fill', 'none');\n    prependIcon.style.marginLeft = '-6px';\n  }\n\n  function setupCloseBtn(): HTMLSpanElement {\n    const closeBtn = document.createElement('span');\n    closeBtn.style.cursor = 'pointer';\n    closeBtn.style.marginLeft = '16px';\n    closeBtn.style.fontSize = '24px';\n    closeBtn.innerHTML = ' &times;';\n    closeBtn.onclick = () => {\n      previouslyDismissed = true;\n      tearDown();\n    };\n    return closeBtn;\n  }\n\n  function setupLinkStyles(\n    learnMoreLink: HTMLAnchorElement,\n    learnMoreId: string\n  ): void {\n    learnMoreLink.setAttribute('id', learnMoreId);\n    learnMoreLink.innerText = 'Learn more';\n    learnMoreLink.href =\n      'https://firebase.google.com/docs/studio/preview-apps#preview-backend';\n    learnMoreLink.setAttribute('target', '__blank');\n    learnMoreLink.style.paddingLeft = '5px';\n    learnMoreLink.style.textDecoration = 'underline';\n  }\n\n  function setupDom(): void {\n    const banner = getOrCreateEl(bannerId);\n    const firebaseTextId = prefixedId('text');\n    const firebaseText: HTMLSpanElement =\n      document.getElementById(firebaseTextId) || document.createElement('span');\n    const learnMoreId = prefixedId('learnmore');\n    const learnMoreLink: HTMLAnchorElement =\n      (document.getElementById(learnMoreId) as HTMLAnchorElement) ||\n      document.createElement('a');\n    const prependIconId = prefixedId('preprendIcon');\n    const prependIcon: SVGElement =\n      (document.getElementById(\n        prependIconId\n      ) as HTMLOrSVGElement as SVGElement) ||\n      document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n    if (banner.created) {\n      // update styles\n      const bannerEl = banner.element;\n      setupBannerStyles(bannerEl);\n      setupLinkStyles(learnMoreLink, learnMoreId);\n      const closeBtn = setupCloseBtn();\n      setupIconStyles(prependIcon, prependIconId);\n      bannerEl.append(prependIcon, firebaseText, learnMoreLink, closeBtn);\n      document.body.appendChild(bannerEl);\n    }\n\n    if (showError) {\n      firebaseText.innerText = `Preview backend disconnected.`;\n      prependIcon.innerHTML = `<g clip-path=\"url(#clip0_6013_33858)\">\n<path d=\"M4.8 17.6L12 5.6L19.2 17.6H4.8ZM6.91667 16.4H17.0833L12 7.93333L6.91667 16.4ZM12 15.6C12.1667 15.6 12.3056 15.5444 12.4167 15.4333C12.5389 15.3111 12.6 15.1667 12.6 15C12.6 14.8333 12.5389 14.6944 12.4167 14.5833C12.3056 14.4611 12.1667 14.4 12 14.4C11.8333 14.4 11.6889 14.4611 11.5667 14.5833C11.4556 14.6944 11.4 14.8333 11.4 15C11.4 15.1667 11.4556 15.3111 11.5667 15.4333C11.6889 15.5444 11.8333 15.6 12 15.6ZM11.4 13.6H12.6V10.4H11.4V13.6Z\" fill=\"#212121\"/>\n</g>\n<defs>\n<clipPath id=\"clip0_6013_33858\">\n<rect width=\"24\" height=\"24\" fill=\"white\"/>\n</clipPath>\n</defs>`;\n    } else {\n      prependIcon.innerHTML = `<g clip-path=\"url(#clip0_6083_34804)\">\n<path d=\"M11.4 15.2H12.6V11.2H11.4V15.2ZM12 10C12.1667 10 12.3056 9.94444 12.4167 9.83333C12.5389 9.71111 12.6 9.56667 12.6 9.4C12.6 9.23333 12.5389 9.09444 12.4167 8.98333C12.3056 8.86111 12.1667 8.8 12 8.8C11.8333 8.8 11.6889 8.86111 11.5667 8.98333C11.4556 9.09444 11.4 9.23333 11.4 9.4C11.4 9.56667 11.4556 9.71111 11.5667 9.83333C11.6889 9.94444 11.8333 10 12 10ZM12 18.4C11.1222 18.4 10.2944 18.2333 9.51667 17.9C8.73889 17.5667 8.05556 17.1111 7.46667 16.5333C6.88889 15.9444 6.43333 15.2611 6.1 14.4833C5.76667 13.7056 5.6 12.8778 5.6 12C5.6 11.1111 5.76667 10.2833 6.1 9.51667C6.43333 8.73889 6.88889 8.06111 7.46667 7.48333C8.05556 6.89444 8.73889 6.43333 9.51667 6.1C10.2944 5.76667 11.1222 5.6 12 5.6C12.8889 5.6 13.7167 5.76667 14.4833 6.1C15.2611 6.43333 15.9389 6.89444 16.5167 7.48333C17.1056 8.06111 17.5667 8.73889 17.9 9.51667C18.2333 10.2833 18.4 11.1111 18.4 12C18.4 12.8778 18.2333 13.7056 17.9 14.4833C17.5667 15.2611 17.1056 15.9444 16.5167 16.5333C15.9389 17.1111 15.2611 17.5667 14.4833 17.9C13.7167 18.2333 12.8889 18.4 12 18.4ZM12 17.2C13.4444 17.2 14.6722 16.6944 15.6833 15.6833C16.6944 14.6722 17.2 13.4444 17.2 12C17.2 10.5556 16.6944 9.32778 15.6833 8.31667C14.6722 7.30555 13.4444 6.8 12 6.8C10.5556 6.8 9.32778 7.30555 8.31667 8.31667C7.30556 9.32778 6.8 10.5556 6.8 12C6.8 13.4444 7.30556 14.6722 8.31667 15.6833C9.32778 16.6944 10.5556 17.2 12 17.2Z\" fill=\"#212121\"/>\n</g>\n<defs>\n<clipPath id=\"clip0_6083_34804\">\n<rect width=\"24\" height=\"24\" fill=\"white\"/>\n</clipPath>\n</defs>`;\n      firebaseText.innerText = 'Preview backend running in this workspace.';\n    }\n    firebaseText.setAttribute('id', firebaseTextId);\n  }\n  if (document.readyState === 'loading') {\n    window.addEventListener('DOMContentLoaded', setupDom);\n  } else {\n    setupDom();\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\nimport { getDefaults } from './defaults';\n\n/**\n * Type placeholder for `WorkerGlobalScope` from `webworker`\n */\ndeclare class WorkerGlobalScope {}\n\n/**\n * Returns navigator.userAgent string or '' if it's not defined.\n * @return user agent string\n */\nexport function getUA(): string {\n  if (\n    typeof navigator !== 'undefined' &&\n    typeof navigator['userAgent'] === 'string'\n  ) {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n\n/**\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\n *\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\n * wait for a callback.\n */\nexport function isMobileCordova(): boolean {\n  return (\n    typeof window !== 'undefined' &&\n    // @ts-ignore Setting up an broadly applicable index signature for Window\n    // just to deal with this case would probably be a bad idea.\n    !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&\n    /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA())\n  );\n}\n\n/**\n * Detect Node.js.\n *\n * @return true if Node.js environment is detected or specified.\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nexport function isNode(): boolean {\n  const forceEnvironment = getDefaults()?.forceEnvironment;\n  if (forceEnvironment === 'node') {\n    return true;\n  } else if (forceEnvironment === 'browser') {\n    return false;\n  }\n\n  try {\n    return (\n      Object.prototype.toString.call(global.process) === '[object process]'\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Detect Browser Environment.\n * Note: This will return true for certain test frameworks that are incompletely\n * mimicking a browser, and should not lead to assuming all browser APIs are\n * available.\n */\nexport function isBrowser(): boolean {\n  return typeof window !== 'undefined' || isWebWorker();\n}\n\n/**\n * Detect Web Worker context.\n */\nexport function isWebWorker(): boolean {\n  return (\n    typeof WorkerGlobalScope !== 'undefined' &&\n    typeof self !== 'undefined' &&\n    self instanceof WorkerGlobalScope\n  );\n}\n\n/**\n * Detect Cloudflare Worker context.\n */\nexport function isCloudflareWorker(): boolean {\n  return (\n    typeof navigator !== 'undefined' &&\n    navigator.userAgent === 'Cloudflare-Workers'\n  );\n}\n\n/**\n * Detect browser extensions (Chrome and Firefox at least).\n */\ninterface BrowserRuntime {\n  id?: unknown;\n}\ndeclare const chrome: { runtime?: BrowserRuntime };\ndeclare const browser: { runtime?: BrowserRuntime };\nexport function isBrowserExtension(): boolean {\n  const runtime =\n    typeof chrome === 'object'\n      ? chrome.runtime\n      : typeof browser === 'object'\n      ? browser.runtime\n      : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n\n/**\n * Detect React Native.\n *\n * @return true if ReactNative environment is detected.\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator === 'object' && navigator['product'] === 'ReactNative'\n  );\n}\n\n/** Detects Electron apps. */\nexport function isElectron(): boolean {\n  return getUA().indexOf('Electron/') >= 0;\n}\n\n/** Detects Internet Explorer. */\nexport function isIE(): boolean {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n\n/** Detects Universal Windows Platform apps. */\nexport function isUWP(): boolean {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n\n/**\n * Detect whether the current SDK build is the Node version.\n *\n * @return true if it's the Node SDK build.\n */\nexport function isNodeSdk(): boolean {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n\n/** Returns true if we are running in Safari. */\nexport function isSafari(): boolean {\n  return (\n    !isNode() &&\n    !!navigator.userAgent &&\n    navigator.userAgent.includes('Safari') &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/** Returns true if we are running in Safari or WebKit */\nexport function isSafariOrWebkit(): boolean {\n  return (\n    !isNode() &&\n    !!navigator.userAgent &&\n    (navigator.userAgent.includes('Safari') ||\n      navigator.userAgent.includes('WebKit')) &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nexport function isIndexedDBAvailable(): boolean {\n  try {\n    return typeof indexedDB === 'object';\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\n *\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\n * private browsing)\n */\nexport function validateIndexedDBOpenable(): Promise<boolean> {\n  return new Promise((resolve, reject) => {\n    try {\n      let preExist: boolean = true;\n      const DB_CHECK_NAME =\n        'validate-browser-context-for-indexeddb-analytics-module';\n      const request = self.indexedDB.open(DB_CHECK_NAME);\n      request.onsuccess = () => {\n        request.result.close();\n        // delete database only when it doesn't pre-exist\n        if (!preExist) {\n          self.indexedDB.deleteDatabase(DB_CHECK_NAME);\n        }\n        resolve(true);\n      };\n      request.onupgradeneeded = () => {\n        preExist = false;\n      };\n\n      request.onerror = () => {\n        reject(request.error?.message || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n\n/**\n *\n * This method checks whether cookie is enabled within current browser\n * @return true if cookie is enabled within current browser\n */\nexport function areCookiesEnabled(): boolean {\n  if (typeof navigator === 'undefined' || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // TypeScript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if ((e as FirebaseError)?.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\n\nexport type ErrorMap<ErrorCode extends string> = {\n  readonly [K in ErrorCode]: string;\n};\n\nconst ERROR_NAME = 'FirebaseError';\n\nexport interface StringLike {\n  toString(): string;\n}\n\nexport interface ErrorData {\n  [key: string]: unknown;\n}\n\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nexport class FirebaseError extends Error {\n  /** The custom name for all FirebaseErrors. */\n  readonly name: string = ERROR_NAME;\n\n  constructor(\n    /** The error code for this error. */\n    readonly code: string,\n    message: string,\n    /** Custom data for this error. */\n    public customData?: Record<string, unknown>\n  ) {\n    super(message);\n\n    // Fix For ES5\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    // TODO(dlarocque): Replace this with `new.target`: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget\n    //                   which we can now use since we no longer target ES5.\n    Object.setPrototypeOf(this, FirebaseError.prototype);\n\n    // Maintains proper stack trace for where our error was thrown.\n    // Only available on V8.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ErrorFactory.prototype.create);\n    }\n  }\n}\n\nexport class ErrorFactory<\n  ErrorCode extends string,\n  ErrorParams extends { readonly [K in ErrorCode]?: ErrorData } = {}\n> {\n  constructor(\n    private readonly service: string,\n    private readonly serviceName: string,\n    private readonly errors: ErrorMap<ErrorCode>\n  ) {}\n\n  create<K extends ErrorCode>(\n    code: K,\n    ...data: K extends keyof ErrorParams ? [ErrorParams[K]] : []\n  ): FirebaseError {\n    const customData = (data[0] as ErrorData) || {};\n    const fullCode = `${this.service}/${code}`;\n    const template = this.errors[code];\n\n    const message = template ? replaceTemplate(template, customData) : 'Error';\n    // Service Name: Error message (service/code).\n    const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n\n    const error = new FirebaseError(fullCode, fullMessage, customData);\n\n    return error;\n  }\n}\n\nfunction replaceTemplate(template: string, data: ErrorData): string {\n  return template.replace(PATTERN, (_, key) => {\n    const value = data[key];\n    return value != null ? String(value) : `<${key}?>`;\n  });\n}\n\nconst PATTERN = /\\{\\$([^}]+)}/g;\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Evaluates a JSON string into a javascript object.\n *\n * @param {string} str A string containing JSON.\n * @return {*} The javascript object representing the specified JSON.\n */\nexport function jsonEval(str: string): unknown {\n  return JSON.parse(str);\n}\n\n/**\n * Returns JSON representing a javascript object.\n * @param {*} data JavaScript object to be stringified.\n * @return {string} The JSON contents of the object.\n */\nexport function stringify(data: unknown): string {\n  return JSON.stringify(data);\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { base64Decode } from './crypt';\nimport { jsonEval } from './json';\n\ninterface Claims {\n  [key: string]: {};\n}\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token into constituent parts.\n *\n * Notes:\n * - May return with invalid / incomplete claims if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const decode = function (token: string): DecodedToken {\n  let header = {},\n    claims: Claims = {},\n    data = {},\n    signature = '';\n\n  try {\n    const parts = token.split('.');\n    header = jsonEval(base64Decode(parts[0]) || '') as object;\n    claims = jsonEval(base64Decode(parts[1]) || '') as Claims;\n    signature = parts[2];\n    data = claims['d'] || {};\n    delete claims['d'];\n  } catch (e) {}\n\n  return {\n    header,\n    claims,\n    data,\n    signature\n  };\n};\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the\n * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidTimestamp = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  const now: number = Math.floor(new Date().getTime() / 1000);\n  let validSince: number = 0,\n    validUntil: number = 0;\n\n  if (typeof claims === 'object') {\n    if (claims.hasOwnProperty('nbf')) {\n      validSince = claims['nbf'] as number;\n    } else if (claims.hasOwnProperty('iat')) {\n      validSince = claims['iat'] as number;\n    }\n\n    if (claims.hasOwnProperty('exp')) {\n      validUntil = claims['exp'] as number;\n    } else {\n      // token will expire after 24h by default\n      validUntil = validSince + 86400;\n    }\n  }\n\n  return (\n    !!now &&\n    !!validSince &&\n    !!validUntil &&\n    now >= validSince &&\n    now <= validUntil\n  );\n};\n\n/**\n * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.\n *\n * Notes:\n * - May return null if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const issuedAtTime = function (token: string): number | null {\n  const claims: Claims = decode(token).claims;\n  if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {\n    return claims['iat'] as number;\n  }\n  return null;\n};\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidFormat = function (token: string): boolean {\n  const decoded = decode(token),\n    claims = decoded.claims;\n\n  return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');\n};\n\n/**\n * Attempts to peer into an auth token and determine if it's an admin auth token by looking at the claims portion.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isAdmin = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  return typeof claims === 'object' && claims['admin'] === true;\n};\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function contains<T extends object>(obj: T, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\n\nexport function safeGet<T extends object, K extends keyof T>(\n  obj: T,\n  key: K\n): T[K] | undefined {\n  if (Object.prototype.hasOwnProperty.call(obj, key)) {\n    return obj[key];\n  } else {\n    return undefined;\n  }\n}\n\nexport function isEmpty(obj: object): obj is {} {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function map<K extends string, V, U>(\n  obj: { [key in K]: V },\n  fn: (value: V, key: K, obj: { [key in K]: V }) => U,\n  contextObj?: unknown\n): { [key in K]: U } {\n  const res: Partial<{ [key in K]: U }> = {};\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      res[key] = fn.call(contextObj, obj[key], key, obj);\n    }\n  }\n  return res as { [key in K]: U };\n}\n\n/**\n * Deep equal two objects. Support Arrays and Objects.\n */\nexport function deepEqual(a: object, b: object): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  for (const k of aKeys) {\n    if (!bKeys.includes(k)) {\n      return false;\n    }\n\n    const aProp = (a as Record<string, unknown>)[k];\n    const bProp = (b as Record<string, unknown>)[k];\n    if (isObject(aProp) && isObject(bProp)) {\n      if (!deepEqual(aProp, bProp)) {\n        return false;\n      }\n    } else if (aProp !== bProp) {\n      return false;\n    }\n  }\n\n  for (const k of bKeys) {\n    if (!aKeys.includes(k)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isObject(thing: unknown): thing is object {\n  return thing !== null && typeof thing === 'object';\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Deferred } from './deferred';\n\n/**\n * Rejects if the given promise doesn't resolve in timeInMS milliseconds.\n * @internal\n */\nexport function promiseWithTimeout<T>(\n  promise: Promise<T>,\n  timeInMS = 2000\n): Promise<T> {\n  const deferredPromise = new Deferred<T>();\n  setTimeout(() => deferredPromise.reject('timeout!'), timeInMS);\n  promise.then(deferredPromise.resolve, deferredPromise.reject);\n  return deferredPromise.promise;\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Returns a querystring-formatted string (e.g. &arg=val&arg2=val2) from a\n * params object (e.g. {arg: 'val', arg2: 'val2'})\n * Note: You must prepend it with ? when adding it to a URL.\n */\nexport function querystring(querystringParams: {\n  [key: string]: string | number;\n}): string {\n  const params = [];\n  for (const [key, value] of Object.entries(querystringParams)) {\n    if (Array.isArray(value)) {\n      value.forEach(arrayVal => {\n        params.push(\n          encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal)\n        );\n      });\n    } else {\n      params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    }\n  }\n  return params.length ? '&' + params.join('&') : '';\n}\n\n/**\n * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object\n * (e.g. {arg: 'val', arg2: 'val2'})\n */\nexport function querystringDecode(querystring: string): Record<string, string> {\n  const obj: Record<string, string> = {};\n  const tokens = querystring.replace(/^\\?/, '').split('&');\n\n  tokens.forEach(token => {\n    if (token) {\n      const [key, value] = token.split('=');\n      obj[decodeURIComponent(key)] = decodeURIComponent(value);\n    }\n  });\n  return obj;\n}\n\n/**\n * Extract the query string part of a URL, including the leading question mark (if present).\n */\nexport function extractQuerystring(url: string): string {\n  const queryStart = url.indexOf('?');\n  if (!queryStart) {\n    return '';\n  }\n  const fragmentStart = url.indexOf('#', queryStart);\n  return url.substring(\n    queryStart,\n    fragmentStart > 0 ? fragmentStart : undefined\n  );\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @fileoverview SHA-1 cryptographic hash.\n * Variable names follow the notation in FIPS PUB 180-3:\n * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf.\n *\n * Usage:\n *   var sha1 = new sha1();\n *   sha1.update(bytes);\n *   var hash = sha1.digest();\n *\n * Performance:\n *   Chrome 23:   ~400 Mbit/s\n *   Firefox 16:  ~250 Mbit/s\n *\n */\n\n/**\n * SHA-1 cryptographic hash constructor.\n *\n * The properties declared here are discussed in the above algorithm document.\n * @constructor\n * @final\n * @struct\n */\nexport class Sha1 {\n  /**\n   * Holds the previous values of accumulated variables a-e in the compress_\n   * function.\n   * @private\n   */\n  private chain_: number[] = [];\n\n  /**\n   * A buffer holding the partially computed hash result.\n   * @private\n   */\n  private buf_: number[] = [];\n\n  /**\n   * An array of 80 bytes, each a part of the message to be hashed.  Referred to\n   * as the message schedule in the docs.\n   * @private\n   */\n  private W_: number[] = [];\n\n  /**\n   * Contains data needed to pad messages less than 64 bytes.\n   * @private\n   */\n  private pad_: number[] = [];\n\n  /**\n   * @private {number}\n   */\n  private inbuf_: number = 0;\n\n  /**\n   * @private {number}\n   */\n  private total_: number = 0;\n\n  blockSize: number;\n\n  constructor() {\n    this.blockSize = 512 / 8;\n\n    this.pad_[0] = 128;\n    for (let i = 1; i < this.blockSize; ++i) {\n      this.pad_[i] = 0;\n    }\n\n    this.reset();\n  }\n\n  reset(): void {\n    this.chain_[0] = 0x67452301;\n    this.chain_[1] = 0xefcdab89;\n    this.chain_[2] = 0x98badcfe;\n    this.chain_[3] = 0x10325476;\n    this.chain_[4] = 0xc3d2e1f0;\n\n    this.inbuf_ = 0;\n    this.total_ = 0;\n  }\n\n  /**\n   * Internal compress helper function.\n   * @param buf Block to compress.\n   * @param offset Offset of the block in the buffer.\n   * @private\n   */\n  compress_(buf: number[] | Uint8Array | string, offset?: number): void {\n    if (!offset) {\n      offset = 0;\n    }\n\n    const W = this.W_;\n\n    // get 16 big endian words\n    if (typeof buf === 'string') {\n      for (let i = 0; i < 16; i++) {\n        // TODO(user): [bug 8140122] Recent versions of Safari for Mac OS and iOS\n        // have a bug that turns the post-increment ++ operator into pre-increment\n        // during JIT compilation.  We have code that depends heavily on SHA-1 for\n        // correctness and which is affected by this bug, so I've removed all uses\n        // of post-increment ++ in which the result value is used.  We can revert\n        // this change once the Safari bug\n        // (https://bugs.webkit.org/show_bug.cgi?id=109036) has been fixed and\n        // most clients have been updated.\n        W[i] =\n          (buf.charCodeAt(offset) << 24) |\n          (buf.charCodeAt(offset + 1) << 16) |\n          (buf.charCodeAt(offset + 2) << 8) |\n          buf.charCodeAt(offset + 3);\n        offset += 4;\n      }\n    } else {\n      for (let i = 0; i < 16; i++) {\n        W[i] =\n          (buf[offset] << 24) |\n          (buf[offset + 1] << 16) |\n          (buf[offset + 2] << 8) |\n          buf[offset + 3];\n        offset += 4;\n      }\n    }\n\n    // expand to 80 words\n    for (let i = 16; i < 80; i++) {\n      const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n      W[i] = ((t << 1) | (t >>> 31)) & 0xffffffff;\n    }\n\n    let a = this.chain_[0];\n    let b = this.chain_[1];\n    let c = this.chain_[2];\n    let d = this.chain_[3];\n    let e = this.chain_[4];\n    let f, k;\n\n    // TODO(user): Try to unroll this loop to speed up the computation.\n    for (let i = 0; i < 80; i++) {\n      if (i < 40) {\n        if (i < 20) {\n          f = d ^ (b & (c ^ d));\n          k = 0x5a827999;\n        } else {\n          f = b ^ c ^ d;\n          k = 0x6ed9eba1;\n        }\n      } else {\n        if (i < 60) {\n          f = (b & c) | (d & (b | c));\n          k = 0x8f1bbcdc;\n        } else {\n          f = b ^ c ^ d;\n          k = 0xca62c1d6;\n        }\n      }\n\n      const t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) & 0xffffffff;\n      e = d;\n      d = c;\n      c = ((b << 30) | (b >>> 2)) & 0xffffffff;\n      b = a;\n      a = t;\n    }\n\n    this.chain_[0] = (this.chain_[0] + a) & 0xffffffff;\n    this.chain_[1] = (this.chain_[1] + b) & 0xffffffff;\n    this.chain_[2] = (this.chain_[2] + c) & 0xffffffff;\n    this.chain_[3] = (this.chain_[3] + d) & 0xffffffff;\n    this.chain_[4] = (this.chain_[4] + e) & 0xffffffff;\n  }\n\n  update(bytes?: number[] | Uint8Array | string, length?: number): void {\n    // TODO(johnlenz): tighten the function signature and remove this check\n    if (bytes == null) {\n      return;\n    }\n\n    if (length === undefined) {\n      length = bytes.length;\n    }\n\n    const lengthMinusBlock = length - this.blockSize;\n    let n = 0;\n    // Using local instead of member variables gives ~5% speedup on Firefox 16.\n    const buf = this.buf_;\n    let inbuf = this.inbuf_;\n\n    // The outer while loop should execute at most twice.\n    while (n < length) {\n      // When we have no data in the block to top up, we can directly process the\n      // input buffer (assuming it contains sufficient data). This gives ~25%\n      // speedup on Chrome 23 and ~15% speedup on Firefox 16, but requires that\n      // the data is provided in large chunks (or in multiples of 64 bytes).\n      if (inbuf === 0) {\n        while (n <= lengthMinusBlock) {\n          this.compress_(bytes, n);\n          n += this.blockSize;\n        }\n      }\n\n      if (typeof bytes === 'string') {\n        while (n < length) {\n          buf[inbuf] = bytes.charCodeAt(n);\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      } else {\n        while (n < length) {\n          buf[inbuf] = bytes[n];\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      }\n    }\n\n    this.inbuf_ = inbuf;\n    this.total_ += length;\n  }\n\n  /** @override */\n  digest(): number[] {\n    const digest: number[] = [];\n    let totalBits = this.total_ * 8;\n\n    // Add pad 0x80 0x00*.\n    if (this.inbuf_ < 56) {\n      this.update(this.pad_, 56 - this.inbuf_);\n    } else {\n      this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));\n    }\n\n    // Add # bits.\n    for (let i = this.blockSize - 1; i >= 56; i--) {\n      this.buf_[i] = totalBits & 255;\n      totalBits /= 256; // Don't use bit-shifting here!\n    }\n\n    this.compress_(this.buf_);\n\n    let n = 0;\n    for (let i = 0; i < 5; i++) {\n      for (let j = 24; j >= 0; j -= 8) {\n        digest[n] = (this.chain_[i] >> j) & 255;\n        ++n;\n      }\n    }\n    return digest;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport type NextFn<T> = (value: T) => void;\nexport type ErrorFn = (error: Error) => void;\nexport type CompleteFn = () => void;\n\nexport interface Observer<T> {\n  // Called once for each value in a stream of values.\n  next: NextFn<T>;\n\n  // A stream terminates by a single call to EITHER error() or complete().\n  error: ErrorFn;\n\n  // No events will be sent to next() once complete() is called.\n  complete: CompleteFn;\n}\n\nexport type PartialObserver<T> = Partial<Observer<T>>;\n\n// TODO: Support also Unsubscribe.unsubscribe?\nexport type Unsubscribe = () => void;\n\n/**\n * The Subscribe interface has two forms - passing the inline function\n * callbacks, or a object interface with callback properties.\n */\nexport interface Subscribe<T> {\n  (next?: NextFn<T>, error?: ErrorFn, complete?: CompleteFn): Unsubscribe;\n  (observer: PartialObserver<T>): Unsubscribe;\n}\n\nexport interface Observable<T> {\n  // Subscribe method\n  subscribe: Subscribe<T>;\n}\n\nexport type Executor<T> = (observer: Observer<T>) => void;\n\n/**\n * Helper to make a Subscribe function (just like Promise helps make a\n * Thenable).\n *\n * @param executor Function which can make calls to a single Observer\n *     as a proxy.\n * @param onNoObservers Callback when count of Observers goes to zero.\n */\nexport function createSubscribe<T>(\n  executor: Executor<T>,\n  onNoObservers?: Executor<T>\n): Subscribe<T> {\n  const proxy = new ObserverProxy<T>(executor, onNoObservers);\n  return proxy.subscribe.bind(proxy);\n}\n\n/**\n * Implement fan-out for any number of Observers attached via a subscribe\n * function.\n */\nclass ObserverProxy<T> implements Observer<T> {\n  private observers: Array<Observer<T>> | undefined = [];\n  private unsubscribes: Unsubscribe[] = [];\n  private onNoObservers: Executor<T> | undefined;\n  private observerCount = 0;\n  // Micro-task scheduling by calling task.then().\n  private task = Promise.resolve();\n  private finalized = false;\n  private finalError?: Error;\n\n  /**\n   * @param executor Function which can make calls to a single Observer\n   *     as a proxy.\n   * @param onNoObservers Callback when count of Observers goes to zero.\n   */\n  constructor(executor: Executor<T>, onNoObservers?: Executor<T>) {\n    this.onNoObservers = onNoObservers;\n    // Call the executor asynchronously so subscribers that are called\n    // synchronously after the creation of the subscribe function\n    // can still receive the very first value generated in the executor.\n    this.task\n      .then(() => {\n        executor(this);\n      })\n      .catch(e => {\n        this.error(e);\n      });\n  }\n\n  next(value: T): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.next(value);\n    });\n  }\n\n  error(error: Error): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.error(error);\n    });\n    this.close(error);\n  }\n\n  complete(): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.complete();\n    });\n    this.close();\n  }\n\n  /**\n   * Subscribe function that can be used to add an Observer to the fan-out list.\n   *\n   * - We require that no event is sent to a subscriber synchronously to their\n   *   call to subscribe().\n   */\n  subscribe(\n    nextOrObserver?: NextFn<T> | PartialObserver<T>,\n    error?: ErrorFn,\n    complete?: CompleteFn\n  ): Unsubscribe {\n    let observer: Observer<T>;\n\n    if (\n      nextOrObserver === undefined &&\n      error === undefined &&\n      complete === undefined\n    ) {\n      throw new Error('Missing Observer.');\n    }\n\n    // Assemble an Observer object when passed as callback functions.\n    if (\n      implementsAnyMethods(nextOrObserver as { [key: string]: unknown }, [\n        'next',\n        'error',\n        'complete'\n      ])\n    ) {\n      observer = nextOrObserver as Observer<T>;\n    } else {\n      observer = {\n        next: nextOrObserver as NextFn<T>,\n        error,\n        complete\n      } as Observer<T>;\n    }\n\n    if (observer.next === undefined) {\n      observer.next = noop as NextFn<T>;\n    }\n    if (observer.error === undefined) {\n      observer.error = noop as ErrorFn;\n    }\n    if (observer.complete === undefined) {\n      observer.complete = noop as CompleteFn;\n    }\n\n    const unsub = this.unsubscribeOne.bind(this, this.observers!.length);\n\n    // Attempt to subscribe to a terminated Observable - we\n    // just respond to the Observer with the final error or complete\n    // event.\n    if (this.finalized) {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.task.then(() => {\n        try {\n          if (this.finalError) {\n            observer.error(this.finalError);\n          } else {\n            observer.complete();\n          }\n        } catch (e) {\n          // nothing\n        }\n        return;\n      });\n    }\n\n    this.observers!.push(observer as Observer<T>);\n\n    return unsub;\n  }\n\n  // Unsubscribe is synchronous - we guarantee that no events are sent to\n  // any unsubscribed Observer.\n  private unsubscribeOne(i: number): void {\n    if (this.observers === undefined || this.observers[i] === undefined) {\n      return;\n    }\n\n    delete this.observers[i];\n\n    this.observerCount -= 1;\n    if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n      this.onNoObservers(this);\n    }\n  }\n\n  private forEachObserver(fn: (observer: Observer<T>) => void): void {\n    if (this.finalized) {\n      // Already closed by previous event....just eat the additional values.\n      return;\n    }\n\n    // Since sendOne calls asynchronously - there is no chance that\n    // this.observers will become undefined.\n    for (let i = 0; i < this.observers!.length; i++) {\n      this.sendOne(i, fn);\n    }\n  }\n\n  // Call the Observer via one of it's callback function. We are careful to\n  // confirm that the observe has not been unsubscribed since this asynchronous\n  // function had been queued.\n  private sendOne(i: number, fn: (observer: Observer<T>) => void): void {\n    // Execute the callback asynchronously\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      if (this.observers !== undefined && this.observers[i] !== undefined) {\n        try {\n          fn(this.observers[i]);\n        } catch (e) {\n          // Ignore exceptions raised in Observers or missing methods of an\n          // Observer.\n          // Log error to console. b/31404806\n          if (typeof console !== 'undefined' && console.error) {\n            console.error(e);\n          }\n        }\n      }\n    });\n  }\n\n  private close(err?: Error): void {\n    if (this.finalized) {\n      return;\n    }\n    this.finalized = true;\n    if (err !== undefined) {\n      this.finalError = err;\n    }\n    // Proxy is no longer needed - garbage collect references\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      this.observers = undefined;\n      this.onNoObservers = undefined;\n    });\n  }\n}\n\n/** Turn synchronous function into one called asynchronously. */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function async(fn: Function, onError?: ErrorFn): Function {\n  return (...args: unknown[]) => {\n    Promise.resolve(true)\n      .then(() => {\n        fn(...args);\n      })\n      .catch((error: Error) => {\n        if (onError) {\n          onError(error);\n        }\n      });\n  };\n}\n\n/**\n * Return true if the object passed in implements any of the named methods.\n */\nfunction implementsAnyMethods(\n  obj: { [key: string]: unknown },\n  methods: string[]\n): boolean {\n  if (typeof obj !== 'object' || obj === null) {\n    return false;\n  }\n\n  for (const method of methods) {\n    if (method in obj && typeof obj[method] === 'function') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction noop(): void {\n  // do nothing\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Check to make sure the appropriate number of arguments are provided for a public function.\n * Throws an error if it fails.\n *\n * @param fnName The function name\n * @param minCount The minimum number of arguments to allow for the function call\n * @param maxCount The maximum number of argument to allow for the function call\n * @param argCount The actual number of arguments provided.\n */\nexport const validateArgCount = function (\n  fnName: string,\n  minCount: number,\n  maxCount: number,\n  argCount: number\n): void {\n  let argError;\n  if (argCount < minCount) {\n    argError = 'at least ' + minCount;\n  } else if (argCount > maxCount) {\n    argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;\n  }\n  if (argError) {\n    const error =\n      fnName +\n      ' failed: Was called with ' +\n      argCount +\n      (argCount === 1 ? ' argument.' : ' arguments.') +\n      ' Expects ' +\n      argError +\n      '.';\n    throw new Error(error);\n  }\n};\n\n/**\n * Generates a string to prefix an error message about failed argument validation\n *\n * @param fnName The function name\n * @param argName The name of the argument\n * @return The prefix to add to the error thrown for validation.\n */\nexport function errorPrefix(fnName: string, argName: string): string {\n  return `${fnName} failed: ${argName} argument `;\n}\n\n/**\n * @param fnName\n * @param argumentNumber\n * @param namespace\n * @param optional\n */\nexport function validateNamespace(\n  fnName: string,\n  namespace: string,\n  optional: boolean\n): void {\n  if (optional && !namespace) {\n    return;\n  }\n  if (typeof namespace !== 'string') {\n    //TODO: I should do more validation here. We only allow certain chars in namespaces.\n    throw new Error(\n      errorPrefix(fnName, 'namespace') + 'must be a valid firebase namespace.'\n    );\n  }\n}\n\nexport function validateCallback(\n  fnName: string,\n  argumentName: string,\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  callback: Function,\n  optional: boolean\n): void {\n  if (optional && !callback) {\n    return;\n  }\n  if (typeof callback !== 'function') {\n    throw new Error(\n      errorPrefix(fnName, argumentName) + 'must be a valid function.'\n    );\n  }\n}\n\nexport function validateContextObject(\n  fnName: string,\n  argumentName: string,\n  context: unknown,\n  optional: boolean\n): void {\n  if (optional && !context) {\n    return;\n  }\n  if (typeof context !== 'object' || context === null) {\n    throw new Error(\n      errorPrefix(fnName, argumentName) + 'must be a valid context object.'\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { assert } from './assert';\n\n// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they\n// automatically replaced '\\r\\n' with '\\n', and they didn't handle surrogate pairs,\n// so it's been modified.\n\n// Note that not all Unicode characters appear as single characters in JavaScript strings.\n// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters\n// use 2 characters in JavaScript.  All 4-byte UTF-8 characters begin with a first\n// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate\n// pair).\n// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3\n\n/**\n * @param {string} str\n * @return {Array}\n */\nexport const stringToByteArray = function (str: string): number[] {\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n\n    // Is this the lead surrogate in a surrogate pair?\n    if (c >= 0xd800 && c <= 0xdbff) {\n      const high = c - 0xd800; // the high 10 bits.\n      i++;\n      assert(i < str.length, 'Surrogate pair missing trail surrogate.');\n      const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.\n      c = 0x10000 + (high << 10) + low;\n    }\n\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (c < 65536) {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Calculate length without actually converting; useful for doing cheaper validation.\n * @param {string} str\n * @return {number}\n */\nexport const stringLength = function (str: string): number {\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    const c = str.charCodeAt(i);\n    if (c < 128) {\n      p++;\n    } else if (c < 2048) {\n      p += 2;\n    } else if (c >= 0xd800 && c <= 0xdbff) {\n      // Lead surrogate of a surrogate pair.  The pair together will take 4 bytes to represent.\n      p += 4;\n      i++; // skip trail surrogate.\n    } else {\n      p += 3;\n    }\n  }\n  return p;\n};\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The amount of milliseconds to exponentially increase.\n */\nconst DEFAULT_INTERVAL_MILLIS = 1000;\n\n/**\n * The factor to backoff by.\n * Should be a number greater than 1.\n */\nconst DEFAULT_BACKOFF_FACTOR = 2;\n\n/**\n * The maximum milliseconds to increase to.\n *\n * <p>Visible for testing\n */\nexport const MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.\n\n/**\n * The percentage of backoff time to randomize by.\n * See\n * http://go/safe-client-behavior#step-1-determine-the-appropriate-retry-interval-to-handle-spike-traffic\n * for context.\n *\n * <p>Visible for testing\n */\nexport const RANDOM_FACTOR = 0.5;\n\n/**\n * Based on the backoff method from\n * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js.\n * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around.\n */\nexport function calculateBackoffMillis(\n  backoffCount: number,\n  intervalMillis: number = DEFAULT_INTERVAL_MILLIS,\n  backoffFactor: number = DEFAULT_BACKOFF_FACTOR\n): number {\n  // Calculates an exponentially increasing value.\n  // Deviation: calculates value from count and a constant interval, so we only need to save value\n  // and count to restore state.\n  const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);\n\n  // A random \"fuzz\" to avoid waves of retries.\n  // Deviation: randomFactor is required.\n  const randomWait = Math.round(\n    // A fraction of the backoff value to add/subtract.\n    // Deviation: changes multiplication order to improve readability.\n    RANDOM_FACTOR *\n      currBaseValue *\n      // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines\n      // if we add or subtract.\n      (Math.random() - 0.5) *\n      2\n  );\n\n  // Limits backoff to max to avoid effectively permanent backoff.\n  return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Provide English ordinal letters after a number\n */\nexport function ordinal(i: number): string {\n  if (!Number.isFinite(i)) {\n    return `${i}`;\n  }\n  return i + indicator(i);\n}\n\nfunction indicator(i: number): string {\n  i = Math.abs(i);\n  const cent = i % 100;\n  if (cent >= 10 && cent <= 20) {\n    return 'th';\n  }\n  const dec = i % 10;\n  if (dec === 1) {\n    return 'st';\n  }\n  if (dec === 2) {\n    return 'nd';\n  }\n  if (dec === 3) {\n    return 'rd';\n  }\n  return 'th';\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface Compat<T> {\n  _delegate: T;\n}\n\nexport function getModularInstance<ExpService>(\n  service: Compat<ExpService> | ExpService\n): ExpService {\n  if (service && (service as Compat<ExpService>)._delegate) {\n    return (service as Compat<ExpService>)._delegate;\n  } else {\n    return service as ExpService;\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './src/constants';\n\n// Overriding the constant (we should be the only ones doing this)\nCONSTANTS.NODE_CLIENT = true;\n\nexport * from './src/assert';\nexport * from './src/crypt';\nexport * from './src/constants';\nexport * from './src/deepCopy';\nexport * from './src/defaults';\nexport * from './src/deferred';\nexport * from './src/emulator';\nexport * from './src/environment';\nexport * from './src/errors';\nexport * from './src/json';\nexport * from './src/jwt';\nexport * from './src/obj';\nexport * from './src/promise';\nexport * from './src/query';\nexport * from './src/sha1';\nexport * from './src/subscribe';\nexport * from './src/validation';\nexport * from './src/utf8';\nexport * from './src/exponential_backoff';\nexport * from './src/formatters';\nexport * from './src/compat';\nexport * from './src/global';\nexport * from './src/url';\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  InstantiationMode,\n  InstanceFactory,\n  ComponentType,\n  Dictionary,\n  Name,\n  onInstanceCreatedCallback\n} from './types';\n\n/**\n * Component for service name T, e.g. `auth`, `auth-internal`\n */\nexport class Component<T extends Name = Name> {\n  multipleInstances = false;\n  /**\n   * Properties to be added to the service namespace\n   */\n  serviceProps: Dictionary = {};\n\n  instantiationMode = InstantiationMode.LAZY;\n\n  onInstanceCreated: onInstanceCreatedCallback<T> | null = null;\n\n  /**\n   *\n   * @param name The public service name, e.g. app, auth, firestore, database\n   * @param instanceFactory Service factory responsible for creating the public interface\n   * @param type whether the service provided by the component is public or private\n   */\n  constructor(\n    readonly name: T,\n    readonly instanceFactory: InstanceFactory<T>,\n    readonly type: ComponentType\n  ) {}\n\n  setInstantiationMode(mode: InstantiationMode): this {\n    this.instantiationMode = mode;\n    return this;\n  }\n\n  setMultipleInstances(multipleInstances: boolean): this {\n    this.multipleInstances = multipleInstances;\n    return this;\n  }\n\n  setServiceProps(props: Dictionary): this {\n    this.serviceProps = props;\n    return this;\n  }\n\n  setInstanceCreatedCallback(callback: onInstanceCreatedCallback<T>): this {\n    this.onInstanceCreated = callback;\n    return this;\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Deferred } from '@firebase/util';\nimport { ComponentContainer } from './component_container';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport {\n  InitializeOptions,\n  InstantiationMode,\n  Name,\n  NameServiceMapping,\n  OnInitCallBack\n} from './types';\nimport { Component } from './component';\n\n/**\n * Provider for instance for service name T, e.g. 'auth', 'auth-internal'\n * NameServiceMapping[T] is an alias for the type of the instance\n */\nexport class Provider<T extends Name> {\n  private component: Component<T> | null = null;\n  private readonly instances: Map<string, NameServiceMapping[T]> = new Map();\n  private readonly instancesDeferred: Map<\n    string,\n    Deferred<NameServiceMapping[T]>\n  > = new Map();\n  private readonly instancesOptions: Map<string, Record<string, unknown>> =\n    new Map();\n  private onInitCallbacks: Map<string, Set<OnInitCallBack<T>>> = new Map();\n\n  constructor(\n    private readonly name: T,\n    private readonly container: ComponentContainer\n  ) {}\n\n  /**\n   * @param identifier A provider can provide multiple instances of a service\n   * if this.component.multipleInstances is true.\n   */\n  get(identifier?: string): Promise<NameServiceMapping[T]> {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n\n    if (!this.instancesDeferred.has(normalizedIdentifier)) {\n      const deferred = new Deferred<NameServiceMapping[T]>();\n      this.instancesDeferred.set(normalizedIdentifier, deferred);\n\n      if (\n        this.isInitialized(normalizedIdentifier) ||\n        this.shouldAutoInitialize()\n      ) {\n        // initialize the service if it can be auto-initialized\n        try {\n          const instance = this.getOrInitializeService({\n            instanceIdentifier: normalizedIdentifier\n          });\n          if (instance) {\n            deferred.resolve(instance);\n          }\n        } catch (e) {\n          // when the instance factory throws an exception during get(), it should not cause\n          // a fatal error. We just return the unresolved promise in this case.\n        }\n      }\n    }\n\n    return this.instancesDeferred.get(normalizedIdentifier)!.promise;\n  }\n\n  /**\n   *\n   * @param options.identifier A provider can provide multiple instances of a service\n   * if this.component.multipleInstances is true.\n   * @param options.optional If optional is false or not provided, the method throws an error when\n   * the service is not immediately available.\n   * If optional is true, the method returns null if the service is not immediately available.\n   */\n  getImmediate(options: {\n    identifier?: string;\n    optional: true;\n  }): NameServiceMapping[T] | null;\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: false;\n  }): NameServiceMapping[T];\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: boolean;\n  }): NameServiceMapping[T] | null {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      options?.identifier\n    );\n    const optional = options?.optional ?? false;\n\n    if (\n      this.isInitialized(normalizedIdentifier) ||\n      this.shouldAutoInitialize()\n    ) {\n      try {\n        return this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        });\n      } catch (e) {\n        if (optional) {\n          return null;\n        } else {\n          throw e;\n        }\n      }\n    } else {\n      // In case a component is not initialized and should/cannot be auto-initialized at the moment, return null if the optional flag is set, or throw\n      if (optional) {\n        return null;\n      } else {\n        throw Error(`Service ${this.name} is not available`);\n      }\n    }\n  }\n\n  getComponent(): Component<T> | null {\n    return this.component;\n  }\n\n  setComponent(component: Component<T>): void {\n    if (component.name !== this.name) {\n      throw Error(\n        `Mismatching Component ${component.name} for Provider ${this.name}.`\n      );\n    }\n\n    if (this.component) {\n      throw Error(`Component for ${this.name} has already been provided`);\n    }\n\n    this.component = component;\n\n    // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`)\n    if (!this.shouldAutoInitialize()) {\n      return;\n    }\n\n    // if the service is eager, initialize the default instance\n    if (isComponentEager(component)) {\n      try {\n        this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });\n      } catch (e) {\n        // when the instance factory for an eager Component throws an exception during the eager\n        // initialization, it should not cause a fatal error.\n        // TODO: Investigate if we need to make it configurable, because some component may want to cause\n        // a fatal error in this case?\n      }\n    }\n\n    // Create service instances for the pending promises and resolve them\n    // NOTE: if this.multipleInstances is false, only the default instance will be created\n    // and all promises with resolve with it regardless of the identifier.\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n\n      try {\n        // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.\n        const instance = this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        })!;\n        instanceDeferred.resolve(instance);\n      } catch (e) {\n        // when the instance factory throws an exception, it should not cause\n        // a fatal error. We just leave the promise unresolved.\n      }\n    }\n  }\n\n  clearInstance(identifier: string = DEFAULT_ENTRY_NAME): void {\n    this.instancesDeferred.delete(identifier);\n    this.instancesOptions.delete(identifier);\n    this.instances.delete(identifier);\n  }\n\n  // app.delete() will call this method on every provider to delete the services\n  // TODO: should we mark the provider as deleted?\n  async delete(): Promise<void> {\n    const services = Array.from(this.instances.values());\n\n    await Promise.all([\n      ...services\n        .filter(service => 'INTERNAL' in service) // legacy services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any).INTERNAL!.delete()),\n      ...services\n        .filter(service => '_delete' in service) // modularized services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any)._delete())\n    ]);\n  }\n\n  isComponentSet(): boolean {\n    return this.component != null;\n  }\n\n  isInitialized(identifier: string = DEFAULT_ENTRY_NAME): boolean {\n    return this.instances.has(identifier);\n  }\n\n  getOptions(identifier: string = DEFAULT_ENTRY_NAME): Record<string, unknown> {\n    return this.instancesOptions.get(identifier) || {};\n  }\n\n  initialize(opts: InitializeOptions = {}): NameServiceMapping[T] {\n    const { options = {} } = opts;\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      opts.instanceIdentifier\n    );\n    if (this.isInitialized(normalizedIdentifier)) {\n      throw Error(\n        `${this.name}(${normalizedIdentifier}) has already been initialized`\n      );\n    }\n\n    if (!this.isComponentSet()) {\n      throw Error(`Component ${this.name} has not been registered yet`);\n    }\n\n    const instance = this.getOrInitializeService({\n      instanceIdentifier: normalizedIdentifier,\n      options\n    })!;\n\n    // resolve any pending promise waiting for the service instance\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedDeferredIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n      if (normalizedIdentifier === normalizedDeferredIdentifier) {\n        instanceDeferred.resolve(instance);\n      }\n    }\n\n    return instance;\n  }\n\n  /**\n   *\n   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().\n   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.\n   *\n   * @param identifier An optional instance identifier\n   * @returns a function to unregister the callback\n   */\n  onInit(callback: OnInitCallBack<T>, identifier?: string): () => void {\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    const existingCallbacks =\n      this.onInitCallbacks.get(normalizedIdentifier) ??\n      new Set<OnInitCallBack<T>>();\n    existingCallbacks.add(callback);\n    this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);\n\n    const existingInstance = this.instances.get(normalizedIdentifier);\n    if (existingInstance) {\n      callback(existingInstance, normalizedIdentifier);\n    }\n\n    return () => {\n      existingCallbacks.delete(callback);\n    };\n  }\n\n  /**\n   * Invoke onInit callbacks synchronously\n   * @param instance the service instance`\n   */\n  private invokeOnInitCallbacks(\n    instance: NameServiceMapping[T],\n    identifier: string\n  ): void {\n    const callbacks = this.onInitCallbacks.get(identifier);\n    if (!callbacks) {\n      return;\n    }\n    for (const callback of callbacks) {\n      try {\n        callback(instance, identifier);\n      } catch {\n        // ignore errors in the onInit callback\n      }\n    }\n  }\n\n  private getOrInitializeService({\n    instanceIdentifier,\n    options = {}\n  }: {\n    instanceIdentifier: string;\n    options?: Record<string, unknown>;\n  }): NameServiceMapping[T] | null {\n    let instance = this.instances.get(instanceIdentifier);\n    if (!instance && this.component) {\n      instance = this.component.instanceFactory(this.container, {\n        instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),\n        options\n      });\n      this.instances.set(instanceIdentifier, instance!);\n      this.instancesOptions.set(instanceIdentifier, options);\n\n      /**\n       * Invoke onInit listeners.\n       * Note this.component.onInstanceCreated is different, which is used by the component creator,\n       * while onInit listeners are registered by consumers of the provider.\n       */\n      this.invokeOnInitCallbacks(instance!, instanceIdentifier);\n\n      /**\n       * Order is important\n       * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which\n       * makes `isInitialized()` return true.\n       */\n      if (this.component.onInstanceCreated) {\n        try {\n          this.component.onInstanceCreated(\n            this.container,\n            instanceIdentifier,\n            instance!\n          );\n        } catch {\n          // ignore errors in the onInstanceCreatedCallback\n        }\n      }\n    }\n\n    return instance || null;\n  }\n\n  private normalizeInstanceIdentifier(\n    identifier: string = DEFAULT_ENTRY_NAME\n  ): string {\n    if (this.component) {\n      return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;\n    } else {\n      return identifier; // assume multiple instances are supported before the component is provided.\n    }\n  }\n\n  private shouldAutoInitialize(): boolean {\n    return (\n      !!this.component &&\n      this.component.instantiationMode !== InstantiationMode.EXPLICIT\n    );\n  }\n}\n\n// undefined should be passed to the service factory for the default instance\nfunction normalizeIdentifierForFactory(identifier: string): string | undefined {\n  return identifier === DEFAULT_ENTRY_NAME ? undefined : identifier;\n}\n\nfunction isComponentEager<T extends Name>(component: Component<T>): boolean {\n  return component.instantiationMode === InstantiationMode.EAGER;\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Provider } from './provider';\nimport { Component } from './component';\nimport { Name } from './types';\n\n/**\n * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal`\n */\nexport class ComponentContainer {\n  private readonly providers = new Map<string, Provider<Name>>();\n\n  constructor(private readonly name: string) {}\n\n  /**\n   *\n   * @param component Component being added\n   * @param overwrite When a component with the same name has already been registered,\n   * if overwrite is true: overwrite the existing component with the new component and create a new\n   * provider with the new component. It can be useful in tests where you want to use different mocks\n   * for different tests.\n   * if overwrite is false: throw an exception\n   */\n  addComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      throw new Error(\n        `Component ${component.name} has already been registered with ${this.name}`\n      );\n    }\n\n    provider.setComponent(component);\n  }\n\n  addOrOverwriteComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      // delete the existing provider from the container, so we can register the new component\n      this.providers.delete(component.name);\n    }\n\n    this.addComponent(component);\n  }\n\n  /**\n   * getProvider provides a type safe interface where it can only be called with a field name\n   * present in NameServiceMapping interface.\n   *\n   * Firebase SDKs providing services should extend NameServiceMapping interface to register\n   * themselves.\n   */\n  getProvider<T extends Name>(name: T): Provider<T> {\n    if (this.providers.has(name)) {\n      return this.providers.get(name) as unknown as Provider<T>;\n    }\n\n    // create a Provider for a service that hasn't registered with Firebase\n    const provider = new Provider<T>(name, this);\n    this.providers.set(name, provider as unknown as Provider<Name>);\n\n    return provider as Provider<T>;\n  }\n\n  getProviders(): Array<Provider<Name>> {\n    return Array.from(this.providers.values());\n  }\n}\n", "/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type LogLevelString =\n  | 'debug'\n  | 'verbose'\n  | 'info'\n  | 'warn'\n  | 'error'\n  | 'silent';\n\nexport interface LogOptions {\n  level: LogLevelString;\n}\n\nexport type LogCallback = (callbackParams: LogCallbackParams) => void;\n\nexport interface LogCallbackParams {\n  level: LogLevelString;\n  message: string;\n  args: unknown[];\n  type: string;\n}\n\n/**\n * A container for all of the Logger instances\n */\nexport const instances: Logger[] = [];\n\n/**\n * The JS SDK supports 5 log levels and also allows a user the ability to\n * silence the logs altogether.\n *\n * The order is a follows:\n * DEBUG < VERBOSE < INFO < WARN < ERROR\n *\n * All of the log types above the current log level will be captured (i.e. if\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\n * `VERBOSE` logs will not)\n */\nexport enum LogLevel {\n  DEBUG,\n  VERBOSE,\n  INFO,\n  WARN,\n  ERROR,\n  SILENT\n}\n\nconst levelStringToEnum: { [key in LogLevelString]: LogLevel } = {\n  'debug': LogLevel.DEBUG,\n  'verbose': LogLevel.VERBOSE,\n  'info': LogLevel.INFO,\n  'warn': LogLevel.WARN,\n  'error': LogLevel.ERROR,\n  'silent': LogLevel.SILENT\n};\n\n/**\n * The default log level\n */\nconst defaultLogLevel: LogLevel = LogLevel.INFO;\n\n/**\n * We allow users the ability to pass their own log handler. We will pass the\n * type of log, the current log level, and any other arguments passed (i.e. the\n * messages that the user wants to log) to this function.\n */\nexport type LogHandler = (\n  loggerInstance: Logger,\n  logType: LogLevel,\n  ...args: unknown[]\n) => void;\n\n/**\n * By default, `console.debug` is not displayed in the developer console (in\n * chrome). To avoid forcing users to have to opt-in to these logs twice\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\n * logs to the `console.log` function.\n */\nconst ConsoleMethod = {\n  [LogLevel.DEBUG]: 'log',\n  [LogLevel.VERBOSE]: 'log',\n  [LogLevel.INFO]: 'info',\n  [LogLevel.WARN]: 'warn',\n  [LogLevel.ERROR]: 'error'\n};\n\n/**\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\n * messages on to their corresponding console counterparts (if the log method\n * is supported by the current log level)\n */\nconst defaultLogHandler: LogHandler = (instance, logType, ...args): void => {\n  if (logType < instance.logLevel) {\n    return;\n  }\n  const now = new Date().toISOString();\n  const method = ConsoleMethod[logType as keyof typeof ConsoleMethod];\n  if (method) {\n    console[method as 'log' | 'info' | 'warn' | 'error'](\n      `[${now}]  ${instance.name}:`,\n      ...args\n    );\n  } else {\n    throw new Error(\n      `Attempted to log a message with an invalid logType (value: ${logType})`\n    );\n  }\n};\n\nexport class Logger {\n  /**\n   * Gives you an instance of a Logger to capture messages according to\n   * Firebase's logging scheme.\n   *\n   * @param name The name that the logs will be associated with\n   */\n  constructor(public name: string) {\n    /**\n     * Capture the current instance for later use\n     */\n    instances.push(this);\n  }\n\n  /**\n   * The log level of the given Logger instance.\n   */\n  private _logLevel = defaultLogLevel;\n\n  get logLevel(): LogLevel {\n    return this._logLevel;\n  }\n\n  set logLevel(val: LogLevel) {\n    if (!(val in LogLevel)) {\n      throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``);\n    }\n    this._logLevel = val;\n  }\n\n  // Workaround for setter/getter having to be the same type.\n  setLogLevel(val: LogLevel | LogLevelString): void {\n    this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;\n  }\n\n  /**\n   * The main (internal) log handler for the Logger instance.\n   * Can be set to a new function in internal package code but not by user.\n   */\n  private _logHandler: LogHandler = defaultLogHandler;\n  get logHandler(): LogHandler {\n    return this._logHandler;\n  }\n  set logHandler(val: LogHandler) {\n    if (typeof val !== 'function') {\n      throw new TypeError('Value assigned to `logHandler` must be a function');\n    }\n    this._logHandler = val;\n  }\n\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  private _userLogHandler: LogHandler | null = null;\n  get userLogHandler(): LogHandler | null {\n    return this._userLogHandler;\n  }\n  set userLogHandler(val: LogHandler | null) {\n    this._userLogHandler = val;\n  }\n\n  /**\n   * The functions below are all based on the `console` interface\n   */\n\n  debug(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);\n    this._logHandler(this, LogLevel.DEBUG, ...args);\n  }\n  log(...args: unknown[]): void {\n    this._userLogHandler &&\n      this._userLogHandler(this, LogLevel.VERBOSE, ...args);\n    this._logHandler(this, LogLevel.VERBOSE, ...args);\n  }\n  info(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);\n    this._logHandler(this, LogLevel.INFO, ...args);\n  }\n  warn(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);\n    this._logHandler(this, LogLevel.WARN, ...args);\n  }\n  error(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);\n    this._logHandler(this, LogLevel.ERROR, ...args);\n  }\n}\n\nexport function setLogLevel(level: LogLevelString | LogLevel): void {\n  instances.forEach(inst => {\n    inst.setLogLevel(level);\n  });\n}\n\nexport function setUserLogHandler(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  for (const instance of instances) {\n    let customLogLevel: LogLevel | null = null;\n    if (options && options.level) {\n      customLogLevel = levelStringToEnum[options.level];\n    }\n    if (logCallback === null) {\n      instance.userLogHandler = null;\n    } else {\n      instance.userLogHandler = (\n        instance: Logger,\n        level: LogLevel,\n        ...args: unknown[]\n      ) => {\n        const message = args\n          .map(arg => {\n            if (arg == null) {\n              return null;\n            } else if (typeof arg === 'string') {\n              return arg;\n            } else if (typeof arg === 'number' || typeof arg === 'boolean') {\n              return arg.toString();\n            } else if (arg instanceof Error) {\n              return arg.message;\n            } else {\n              try {\n                return JSON.stringify(arg);\n              } catch (ignored) {\n                return null;\n              }\n            }\n          })\n          .filter(arg => arg)\n          .join(' ');\n        if (level >= (customLogLevel ?? instance.logLevel)) {\n          logCallback({\n            level: LogLevel[level].toLowerCase() as LogLevelString,\n            message,\n            args,\n            type: instance.name\n          });\n        }\n      };\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ComponentContainer,\n  ComponentType,\n  Provider,\n  Name\n} from '@firebase/component';\nimport { PlatformLoggerService, VersionService } from './types';\n\nexport class PlatformLoggerServiceImpl implements PlatformLoggerService {\n  constructor(private readonly container: ComponentContainer) {}\n  // In initial implementation, this will be called by installations on\n  // auth token refresh, and installations will send this string.\n  getPlatformInfoString(): string {\n    const providers = this.container.getProviders();\n    // Loop through providers and get library/version pairs from any that are\n    // version components.\n    return providers\n      .map(provider => {\n        if (isVersionServiceProvider(provider)) {\n          const service = provider.getImmediate() as VersionService;\n          return `${service.library}/${service.version}`;\n        } else {\n          return null;\n        }\n      })\n      .filter(logString => logString)\n      .join(' ');\n  }\n}\n/**\n *\n * @param provider check if this provider provides a VersionService\n *\n * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider\n * provides VersionService. The provider is not necessarily a 'app-version'\n * provider.\n */\nfunction isVersionServiceProvider(provider: Provider<Name>): boolean {\n  const component = provider.getComponent();\n  return component?.type === ComponentType.VERSION;\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger } from '@firebase/logger';\n\nexport const logger = new Logger('@firebase/app');\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { name as appName } from '../package.json';\nimport { name as appCompatName } from '../../app-compat/package.json';\nimport { name as analyticsCompatName } from '../../../packages/analytics-compat/package.json';\nimport { name as analyticsName } from '../../../packages/analytics/package.json';\nimport { name as appCheckCompatName } from '../../../packages/app-check-compat/package.json';\nimport { name as appCheckName } from '../../../packages/app-check/package.json';\nimport { name as authName } from '../../../packages/auth/package.json';\nimport { name as authCompatName } from '../../../packages/auth-compat/package.json';\nimport { name as databaseName } from '../../../packages/database/package.json';\nimport { name as dataconnectName } from '../../../packages/data-connect/package.json';\nimport { name as databaseCompatName } from '../../../packages/database-compat/package.json';\nimport { name as functionsName } from '../../../packages/functions/package.json';\nimport { name as functionsCompatName } from '../../../packages/functions-compat/package.json';\nimport { name as installationsName } from '../../../packages/installations/package.json';\nimport { name as installationsCompatName } from '../../../packages/installations-compat/package.json';\nimport { name as messagingName } from '../../../packages/messaging/package.json';\nimport { name as messagingCompatName } from '../../../packages/messaging-compat/package.json';\nimport { name as performanceName } from '../../../packages/performance/package.json';\nimport { name as performanceCompatName } from '../../../packages/performance-compat/package.json';\nimport { name as remoteConfigName } from '../../../packages/remote-config/package.json';\nimport { name as remoteConfigCompatName } from '../../../packages/remote-config-compat/package.json';\nimport { name as storageName } from '../../../packages/storage/package.json';\nimport { name as storageCompatName } from '../../../packages/storage-compat/package.json';\nimport { name as firestoreName } from '../../../packages/firestore/package.json';\nimport { name as aiName } from '../../../packages/ai/package.json';\nimport { name as firestoreCompatName } from '../../../packages/firestore-compat/package.json';\nimport { name as packageName } from '../../../packages/firebase/package.json';\n\n/**\n * The default app name\n *\n * @internal\n */\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\n\nexport const PLATFORM_LOG_STRING = {\n  [appName]: 'fire-core',\n  [appCompatName]: 'fire-core-compat',\n  [analyticsName]: 'fire-analytics',\n  [analyticsCompatName]: 'fire-analytics-compat',\n  [appCheckName]: 'fire-app-check',\n  [appCheckCompatName]: 'fire-app-check-compat',\n  [authName]: 'fire-auth',\n  [authCompatName]: 'fire-auth-compat',\n  [databaseName]: 'fire-rtdb',\n  [dataconnectName]: 'fire-data-connect',\n  [databaseCompatName]: 'fire-rtdb-compat',\n  [functionsName]: 'fire-fn',\n  [functionsCompatName]: 'fire-fn-compat',\n  [installationsName]: 'fire-iid',\n  [installationsCompatName]: 'fire-iid-compat',\n  [messagingName]: 'fire-fcm',\n  [messagingCompatName]: 'fire-fcm-compat',\n  [performanceName]: 'fire-perf',\n  [performanceCompatName]: 'fire-perf-compat',\n  [remoteConfigName]: 'fire-rc',\n  [remoteConfigCompatName]: 'fire-rc-compat',\n  [storageName]: 'fire-gcs',\n  [storageCompatName]: 'fire-gcs-compat',\n  [firestoreName]: 'fire-fst',\n  [firestoreCompatName]: 'fire-fst-compat',\n  [aiName]: 'fire-vertex',\n  'fire-js': 'fire-js', // Platform identifier for JS SDK.\n  [packageName]: 'fire-js-all'\n} as const;\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseAppSettings,\n  FirebaseServerAppSettings,\n  FirebaseOptions,\n  FirebaseServerApp\n} from './public-types';\nimport { Component, Provider, Name } from '@firebase/component';\nimport { logger } from './logger';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { FirebaseServerAppImpl } from './firebaseServerApp';\n\n/**\n * @internal\n */\nexport const _apps = new Map<string, FirebaseApp>();\n\n/**\n * @internal\n */\nexport const _serverApps = new Map<string, FirebaseServerApp>();\n\n/**\n * Registered components.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const _components = new Map<string, Component<any>>();\n\n/**\n * @param component - the component being added to this app's container\n *\n * @internal\n */\nexport function _addComponent<T extends Name>(\n  app: FirebaseApp,\n  component: Component<T>\n): void {\n  try {\n    (app as FirebaseAppImpl).container.addComponent(component);\n  } catch (e) {\n    logger.debug(\n      `Component ${component.name} failed to register with FirebaseApp ${app.name}`,\n      e\n    );\n  }\n}\n\n/**\n *\n * @internal\n */\nexport function _addOrOverwriteComponent(\n  app: FirebaseApp,\n  component: Component\n): void {\n  (app as FirebaseAppImpl).container.addOrOverwriteComponent(component);\n}\n\n/**\n *\n * @param component - the component to register\n * @returns whether or not the component is registered successfully\n *\n * @internal\n */\nexport function _registerComponent<T extends Name>(\n  component: Component<T>\n): boolean {\n  const componentName = component.name;\n  if (_components.has(componentName)) {\n    logger.debug(\n      `There were multiple attempts to register component ${componentName}.`\n    );\n\n    return false;\n  }\n\n  _components.set(componentName, component);\n\n  // add the component to existing app instances\n  for (const app of _apps.values()) {\n    _addComponent(app as FirebaseAppImpl, component);\n  }\n\n  for (const serverApp of _serverApps.values()) {\n    _addComponent(serverApp as FirebaseServerAppImpl, component);\n  }\n\n  return true;\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n *\n * @returns the provider for the service with the matching name\n *\n * @internal\n */\nexport function _getProvider<T extends Name>(\n  app: FirebaseApp,\n  name: T\n): Provider<T> {\n  const heartbeatController = (app as FirebaseAppImpl).container\n    .getProvider('heartbeat')\n    .getImmediate({ optional: true });\n  if (heartbeatController) {\n    void heartbeatController.triggerHeartbeat();\n  }\n  return (app as FirebaseAppImpl).container.getProvider(name);\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n * @param instanceIdentifier - service instance identifier in case the service supports multiple instances\n *\n * @internal\n */\nexport function _removeServiceInstance<T extends Name>(\n  app: FirebaseApp,\n  name: T,\n  instanceIdentifier: string = DEFAULT_ENTRY_NAME\n): void {\n  _getProvider(app, name).clearInstance(instanceIdentifier);\n}\n\n/**\n *\n * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.\n *\n * @returns true if the provide object is of type FirebaseApp.\n *\n * @internal\n */\nexport function _isFirebaseApp(\n  obj: FirebaseApp | FirebaseOptions | FirebaseAppSettings\n): obj is FirebaseApp {\n  return (obj as FirebaseApp).options !== undefined;\n}\n\n/**\n *\n * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.\n *\n * @returns true if the provided object is of type FirebaseServerAppImpl.\n *\n * @internal\n */\nexport function _isFirebaseServerAppSettings(\n  obj: FirebaseApp | FirebaseOptions | FirebaseAppSettings\n): obj is FirebaseServerAppSettings {\n  if (_isFirebaseApp(obj)) {\n    return false;\n  }\n  return (\n    'authIdToken' in obj ||\n    'appCheckToken' in obj ||\n    'releaseOnDeref' in obj ||\n    'automaticDataCollectionEnabled' in obj\n  );\n}\n\n/**\n *\n * @param obj - an object of type FirebaseApp.\n *\n * @returns true if the provided object is of type FirebaseServerAppImpl.\n *\n * @internal\n */\nexport function _isFirebaseServerApp(\n  obj: FirebaseApp | FirebaseServerApp | null | undefined\n): obj is FirebaseServerApp {\n  if (obj === null || obj === undefined) {\n    return false;\n  }\n  return (obj as FirebaseServerApp).settings !== undefined;\n}\n\n/**\n * Test only\n *\n * @internal\n */\nexport function _clearComponents(): void {\n  _components.clear();\n}\n\n/**\n * Exported in order to be used in app-compat package\n */\nexport { DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME };\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum AppError {\n  NO_APP = 'no-app',\n  BAD_APP_NAME = 'bad-app-name',\n  DUPLICATE_APP = 'duplicate-app',\n  APP_DELETED = 'app-deleted',\n  SERVER_APP_DELETED = 'server-app-deleted',\n  NO_OPTIONS = 'no-options',\n  INVALID_APP_ARGUMENT = 'invalid-app-argument',\n  INVALID_LOG_ARGUMENT = 'invalid-log-argument',\n  IDB_OPEN = 'idb-open',\n  IDB_GET = 'idb-get',\n  IDB_WRITE = 'idb-set',\n  IDB_DELETE = 'idb-delete',\n  FINALIZATION_REGISTRY_NOT_SUPPORTED = 'finalization-registry-not-supported',\n  INVALID_SERVER_APP_ENVIRONMENT = 'invalid-server-app-environment'\n}\n\nconst ERRORS: ErrorMap<AppError> = {\n  [AppError.NO_APP]:\n    \"No Firebase App '{$appName}' has been created - \" +\n    'call initializeApp() first',\n  [AppError.BAD_APP_NAME]: \"Illegal App name: '{$appName}'\",\n  [AppError.DUPLICATE_APP]:\n    \"Firebase App named '{$appName}' already exists with different options or config\",\n  [AppError.APP_DELETED]: \"Firebase App named '{$appName}' already deleted\",\n  [AppError.SERVER_APP_DELETED]: 'Firebase Server App has been deleted',\n  [AppError.NO_OPTIONS]:\n    'Need to provide options, when not being deployed to hosting via source.',\n  [AppError.INVALID_APP_ARGUMENT]:\n    'firebase.{$appName}() takes either no argument or a ' +\n    'Firebase App instance.',\n  [AppError.INVALID_LOG_ARGUMENT]:\n    'First argument to `onLog` must be null or a function.',\n  [AppError.IDB_OPEN]:\n    'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_GET]:\n    'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_WRITE]:\n    'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_DELETE]:\n    'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED]:\n    'FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.',\n  [AppError.INVALID_SERVER_APP_ENVIRONMENT]:\n    'FirebaseServerApp is not for use in browser environments.'\n};\n\ninterface ErrorParams {\n  [AppError.NO_APP]: { appName: string };\n  [AppError.BAD_APP_NAME]: { appName: string };\n  [AppError.DUPLICATE_APP]: { appName: string };\n  [AppError.APP_DELETED]: { appName: string };\n  [AppError.INVALID_APP_ARGUMENT]: { appName: string };\n  [AppError.IDB_OPEN]: { originalErrorMessage?: string };\n  [AppError.IDB_GET]: { originalErrorMessage?: string };\n  [AppError.IDB_WRITE]: { originalErrorMessage?: string };\n  [AppError.IDB_DELETE]: { originalErrorMessage?: string };\n  [AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED]: { appName?: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<AppError, ErrorParams>(\n  'app',\n  'Firebase',\n  ERRORS\n);\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppSettings\n} from './public-types';\nimport {\n  ComponentContainer,\n  Component,\n  ComponentType\n} from '@firebase/component';\nimport { ERROR_FACTORY, AppError } from './errors';\n\nexport class FirebaseAppImpl implements FirebaseApp {\n  protected readonly _options: FirebaseOptions;\n  protected readonly _name: string;\n  /**\n   * Original config values passed in as a constructor parameter.\n   * It is only used to compare with another config object to support idempotent initializeApp().\n   *\n   * Updating automaticDataCollectionEnabled on the App instance will not change its value in _config.\n   */\n  private readonly _config: Required<FirebaseAppSettings>;\n  private _automaticDataCollectionEnabled: boolean;\n  protected _isDeleted = false;\n  private readonly _container: ComponentContainer;\n\n  constructor(\n    options: FirebaseOptions,\n    config: Required<FirebaseAppSettings>,\n    container: ComponentContainer\n  ) {\n    this._options = { ...options };\n    this._config = { ...config };\n    this._name = config.name;\n    this._automaticDataCollectionEnabled =\n      config.automaticDataCollectionEnabled;\n    this._container = container;\n    this.container.addComponent(\n      new Component('app', () => this, ComponentType.PUBLIC)\n    );\n  }\n\n  get automaticDataCollectionEnabled(): boolean {\n    this.checkDestroyed();\n    return this._automaticDataCollectionEnabled;\n  }\n\n  set automaticDataCollectionEnabled(val: boolean) {\n    this.checkDestroyed();\n    this._automaticDataCollectionEnabled = val;\n  }\n\n  get name(): string {\n    this.checkDestroyed();\n    return this._name;\n  }\n\n  get options(): FirebaseOptions {\n    this.checkDestroyed();\n    return this._options;\n  }\n\n  get config(): Required<FirebaseAppSettings> {\n    this.checkDestroyed();\n    return this._config;\n  }\n\n  get container(): ComponentContainer {\n    return this._container;\n  }\n\n  get isDeleted(): boolean {\n    return this._isDeleted;\n  }\n\n  set isDeleted(val: boolean) {\n    this._isDeleted = val;\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  protected checkDestroyed(): void {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(AppError.APP_DELETED, { appName: this._name });\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseAppSettings,\n  FirebaseServerApp,\n  FirebaseServerAppSettings,\n  FirebaseOptions\n} from './public-types';\nimport { deleteApp, registerVersion } from './api';\nimport { ComponentContainer } from '@firebase/component';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport { name as packageName, version } from '../package.json';\nimport { base64Decode } from '@firebase/util';\n\n// Parse the token and check to see if the `exp` claim is in the future.\n// Reports an error to the console if the token or claim could not be parsed, or if `exp` is in\n// the past.\nfunction validateTokenTTL(base64Token: string, tokenName: string): void {\n  const secondPart = base64Decode(base64Token.split('.')[1]);\n  if (secondPart === null) {\n    console.error(\n      `FirebaseServerApp ${tokenName} is invalid: second part could not be parsed.`\n    );\n    return;\n  }\n  const expClaim = JSON.parse(secondPart).exp;\n  if (expClaim === undefined) {\n    console.error(\n      `FirebaseServerApp ${tokenName} is invalid: expiration claim could not be parsed`\n    );\n    return;\n  }\n  const exp = JSON.parse(secondPart).exp * 1000;\n  const now = new Date().getTime();\n  const diff = exp - now;\n  if (diff <= 0) {\n    console.error(\n      `FirebaseServerApp ${tokenName} is invalid: the token has expired.`\n    );\n  }\n}\n\nexport class FirebaseServerAppImpl\n  extends FirebaseAppImpl\n  implements FirebaseServerApp\n{\n  private readonly _serverConfig: FirebaseServerAppSettings;\n  private _finalizationRegistry: FinalizationRegistry<object> | null;\n  private _refCount: number;\n\n  constructor(\n    options: FirebaseOptions | FirebaseAppImpl,\n    serverConfig: FirebaseServerAppSettings,\n    name: string,\n    container: ComponentContainer\n  ) {\n    // Build configuration parameters for the FirebaseAppImpl base class.\n    const automaticDataCollectionEnabled =\n      serverConfig.automaticDataCollectionEnabled !== undefined\n        ? serverConfig.automaticDataCollectionEnabled\n        : true;\n\n    // Create the FirebaseAppSettings object for the FirebaseAppImp constructor.\n    const config: Required<FirebaseAppSettings> = {\n      name,\n      automaticDataCollectionEnabled\n    };\n\n    if ((options as FirebaseOptions).apiKey !== undefined) {\n      // Construct the parent FirebaseAppImp object.\n      super(options as FirebaseOptions, config, container);\n    } else {\n      const appImpl: FirebaseAppImpl = options as FirebaseAppImpl;\n      super(appImpl.options, config, container);\n    }\n\n    // Now construct the data for the FirebaseServerAppImpl.\n    this._serverConfig = {\n      automaticDataCollectionEnabled,\n      ...serverConfig\n    };\n\n    // Ensure that the current time is within the `authIdtoken` window of validity.\n    if (this._serverConfig.authIdToken) {\n      validateTokenTTL(this._serverConfig.authIdToken, 'authIdToken');\n    }\n\n    // Ensure that the current time is within the `appCheckToken` window of validity.\n    if (this._serverConfig.appCheckToken) {\n      validateTokenTTL(this._serverConfig.appCheckToken, 'appCheckToken');\n    }\n\n    this._finalizationRegistry = null;\n    if (typeof FinalizationRegistry !== 'undefined') {\n      this._finalizationRegistry = new FinalizationRegistry(() => {\n        this.automaticCleanup();\n      });\n    }\n\n    this._refCount = 0;\n    this.incRefCount(this._serverConfig.releaseOnDeref);\n\n    // Do not retain a hard reference to the dref object, otherwise the FinalizationRegistry\n    // will never trigger.\n    this._serverConfig.releaseOnDeref = undefined;\n    serverConfig.releaseOnDeref = undefined;\n\n    registerVersion(packageName, version, 'serverapp');\n  }\n\n  toJSON(): undefined {\n    return undefined;\n  }\n\n  get refCount(): number {\n    return this._refCount;\n  }\n\n  // Increment the reference count of this server app. If an object is provided, register it\n  // with the finalization registry.\n  incRefCount(obj: object | undefined): void {\n    if (this.isDeleted) {\n      return;\n    }\n    this._refCount++;\n    if (obj !== undefined && this._finalizationRegistry !== null) {\n      this._finalizationRegistry.register(obj, this);\n    }\n  }\n\n  // Decrement the reference count.\n  decRefCount(): number {\n    if (this.isDeleted) {\n      return 0;\n    }\n    return --this._refCount;\n  }\n\n  // Invoked by the FinalizationRegistry callback to note that this app should go through its\n  // reference counts and delete itself if no reference count remain. The coordinating logic that\n  // handles this is in deleteApp(...).\n  private automaticCleanup(): void {\n    void deleteApp(this);\n  }\n\n  get settings(): FirebaseServerAppSettings {\n    this.checkDestroyed();\n    return this._serverConfig;\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  protected checkDestroyed(): void {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(AppError.SERVER_APP_DELETED);\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseServerApp,\n  FirebaseOptions,\n  FirebaseAppSettings,\n  FirebaseServerAppSettings\n} from './public-types';\nimport { DEFAULT_ENTRY_NAME, PLATFORM_LOG_STRING } from './constants';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport {\n  ComponentContainer,\n  Component,\n  Name,\n  ComponentType\n} from '@firebase/component';\nimport { version } from '../../firebase/package.json';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { FirebaseServerAppImpl } from './firebaseServerApp';\nimport {\n  _apps,\n  _components,\n  _isFirebaseApp,\n  _isFirebaseServerAppSettings,\n  _registerComponent,\n  _serverApps\n} from './internal';\nimport { logger } from './logger';\nimport {\n  LogLevelString,\n  setLogLevel as setLogLevelImpl,\n  LogCallback,\n  LogOptions,\n  setUserLogHandler\n} from '@firebase/logger';\nimport {\n  deepEqual,\n  getDefaultAppConfig,\n  isBrowser,\n  isWebWorker\n} from '@firebase/util';\n\nexport { FirebaseError } from '@firebase/util';\n\n/**\n * The current SDK version.\n *\n * @public\n */\nexport const SDK_VERSION = version;\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseApp} instance.\n *\n * See\n * {@link\n *   https://firebase.google.com/docs/web/setup#add_firebase_to_your_app\n *   | Add Firebase to your app} and\n * {@link\n *   https://firebase.google.com/docs/web/setup#multiple-projects\n *   | Initialize multiple projects} for detailed documentation.\n *\n * @example\n * ```javascript\n *\n * // Initialize default app\n * // Retrieve your own options values by adding a web app on\n * // https://console.firebase.google.com\n * initializeApp({\n *   apiKey: \"AIza....\",                             // Auth / General Use\n *   authDomain: \"YOUR_APP.firebaseapp.com\",         // Auth with popup/redirect\n *   databaseURL: \"https://YOUR_APP.firebaseio.com\", // Realtime Database\n *   storageBucket: \"YOUR_APP.appspot.com\",          // Storage\n *   messagingSenderId: \"123456789\"                  // Cloud Messaging\n * });\n * ```\n *\n * @example\n * ```javascript\n *\n * // Initialize another app\n * const otherApp = initializeApp({\n *   databaseURL: \"https://<OTHER_DATABASE_NAME>.firebaseio.com\",\n *   storageBucket: \"<OTHER_STORAGE_BUCKET>.appspot.com\"\n * }, \"otherApp\");\n * ```\n *\n * @param options - Options to configure the app's services.\n * @param name - Optional name of the app to initialize. If no name\n *   is provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The initialized app.\n *\n * @throws If the optional `name` parameter is malformed or empty.\n *\n * @throws If a `FirebaseApp` already exists with the same name but with a different configuration.\n *\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  name?: string\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @param options - Options to configure the app's services.\n * @param config - FirebaseApp Configuration\n *\n * @throws If {@link FirebaseAppSettings.name} is defined but the value is malformed or empty.\n *\n * @throws If a `FirebaseApp` already exists with the same name but with a different configuration.\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  config?: FirebaseAppSettings\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @public\n */\nexport function initializeApp(): FirebaseApp;\nexport function initializeApp(\n  _options?: FirebaseOptions,\n  rawConfig = {}\n): FirebaseApp {\n  let options = _options;\n\n  if (typeof rawConfig !== 'object') {\n    const name = rawConfig;\n    rawConfig = { name };\n  }\n\n  const config: Required<FirebaseAppSettings> = {\n    name: DEFAULT_ENTRY_NAME,\n    automaticDataCollectionEnabled: true,\n    ...rawConfig\n  };\n  const name = config.name;\n\n  if (typeof name !== 'string' || !name) {\n    throw ERROR_FACTORY.create(AppError.BAD_APP_NAME, {\n      appName: String(name)\n    });\n  }\n\n  options ||= getDefaultAppConfig();\n\n  if (!options) {\n    throw ERROR_FACTORY.create(AppError.NO_OPTIONS);\n  }\n\n  const existingApp = _apps.get(name) as FirebaseAppImpl;\n  if (existingApp) {\n    // return the existing app if options and config deep equal the ones in the existing app.\n    if (\n      deepEqual(options, existingApp.options) &&\n      deepEqual(config, existingApp.config)\n    ) {\n      return existingApp;\n    } else {\n      throw ERROR_FACTORY.create(AppError.DUPLICATE_APP, { appName: name });\n    }\n  }\n\n  const container = new ComponentContainer(name);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n\n  const newApp = new FirebaseAppImpl(options, config, container);\n\n  _apps.set(name, newApp);\n\n  return newApp;\n}\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseServerApp} instance.\n *\n * The `FirebaseServerApp` is similar to `FirebaseApp`, but is intended for execution in\n * server side rendering environments only. Initialization will fail if invoked from a\n * browser environment.\n *\n * See\n * {@link\n *   https://firebase.google.com/docs/web/setup#add_firebase_to_your_app\n *   | Add Firebase to your app} and\n * {@link\n *   https://firebase.google.com/docs/web/setup#multiple-projects\n *   | Initialize multiple projects} for detailed documentation.\n *\n * @example\n * ```javascript\n *\n * // Initialize an instance of `FirebaseServerApp`.\n * // Retrieve your own options values by adding a web app on\n * // https://console.firebase.google.com\n * initializeServerApp({\n *     apiKey: \"AIza....\",                             // Auth / General Use\n *     authDomain: \"YOUR_APP.firebaseapp.com\",         // Auth with popup/redirect\n *     databaseURL: \"https://YOUR_APP.firebaseio.com\", // Realtime Database\n *     storageBucket: \"YOUR_APP.appspot.com\",          // Storage\n *     messagingSenderId: \"123456789\"                  // Cloud Messaging\n *   },\n *   {\n *    authIdToken: \"Your Auth ID Token\"\n *   });\n * ```\n *\n * @param options - `Firebase.AppOptions` to configure the app's services, or a\n *   a `FirebaseApp` instance which contains the `AppOptions` within.\n * @param config - Optional `FirebaseServerApp` settings.\n *\n * @returns The initialized `FirebaseServerApp`.\n *\n * @throws If invoked in an unsupported non-server environment such as a browser.\n *\n * @throws If {@link FirebaseServerAppSettings.releaseOnDeref} is defined but the runtime doesn't\n *   provide Finalization Registry support.\n *\n * @public\n */\nexport function initializeServerApp(\n  options: FirebaseOptions | FirebaseApp,\n  config?: FirebaseServerAppSettings\n): FirebaseServerApp;\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseServerApp} instance.\n *\n * @param config - Optional `FirebaseServerApp` settings.\n *\n * @returns The initialized `FirebaseServerApp`.\n *\n * @throws If invoked in an unsupported non-server environment such as a browser.\n * @throws If {@link FirebaseServerAppSettings.releaseOnDeref} is defined but the runtime doesn't\n *   provide Finalization Registry support.\n * @throws If the `FIREBASE_OPTIONS` environment variable does not contain a valid project\n *   configuration required for auto-initialization.\n *\n * @public\n */\nexport function initializeServerApp(\n  config?: FirebaseServerAppSettings\n): FirebaseServerApp;\nexport function initializeServerApp(\n  _options?: FirebaseApp | FirebaseServerAppSettings | FirebaseOptions,\n  _serverAppConfig: FirebaseServerAppSettings = {}\n): FirebaseServerApp {\n  if (isBrowser() && !isWebWorker()) {\n    // FirebaseServerApp isn't designed to be run in browsers.\n    throw ERROR_FACTORY.create(AppError.INVALID_SERVER_APP_ENVIRONMENT);\n  }\n\n  let firebaseOptions: FirebaseOptions | undefined;\n  let serverAppSettings: FirebaseServerAppSettings = _serverAppConfig || {};\n\n  if (_options) {\n    if (_isFirebaseApp(_options)) {\n      firebaseOptions = _options.options;\n    } else if (_isFirebaseServerAppSettings(_options)) {\n      serverAppSettings = _options;\n    } else {\n      firebaseOptions = _options;\n    }\n  }\n\n  if (serverAppSettings.automaticDataCollectionEnabled === undefined) {\n    serverAppSettings.automaticDataCollectionEnabled = true;\n  }\n\n  firebaseOptions ||= getDefaultAppConfig();\n  if (!firebaseOptions) {\n    throw ERROR_FACTORY.create(AppError.NO_OPTIONS);\n  }\n\n  // Build an app name based on a hash of the configuration options.\n  const nameObj = {\n    ...serverAppSettings,\n    ...firebaseOptions\n  };\n\n  // However, Do not mangle the name based on releaseOnDeref, since it will vary between the\n  // construction of FirebaseServerApp instances. For example, if the object is the request headers.\n  if (nameObj.releaseOnDeref !== undefined) {\n    delete nameObj.releaseOnDeref;\n  }\n\n  const hashCode = (s: string): number => {\n    return [...s].reduce(\n      (hash, c) => (Math.imul(31, hash) + c.charCodeAt(0)) | 0,\n      0\n    );\n  };\n\n  if (serverAppSettings.releaseOnDeref !== undefined) {\n    if (typeof FinalizationRegistry === 'undefined') {\n      throw ERROR_FACTORY.create(\n        AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED,\n        {}\n      );\n    }\n  }\n\n  const nameString = '' + hashCode(JSON.stringify(nameObj));\n  const existingApp = _serverApps.get(nameString) as FirebaseServerApp;\n  if (existingApp) {\n    (existingApp as FirebaseServerAppImpl).incRefCount(\n      serverAppSettings.releaseOnDeref\n    );\n    return existingApp;\n  }\n\n  const container = new ComponentContainer(nameString);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n\n  const newApp = new FirebaseServerAppImpl(\n    firebaseOptions,\n    serverAppSettings,\n    nameString,\n    container\n  );\n\n  _serverApps.set(nameString, newApp);\n\n  return newApp;\n}\n\n/**\n * Retrieves a {@link @firebase/app#FirebaseApp} instance.\n *\n * When called with no arguments, the default app is returned. When an app name\n * is provided, the app corresponding to that name is returned.\n *\n * An exception is thrown if the app being retrieved has not yet been\n * initialized.\n *\n * @example\n * ```javascript\n * // Return the default app\n * const app = getApp();\n * ```\n *\n * @example\n * ```javascript\n * // Return a named app\n * const otherApp = getApp(\"otherApp\");\n * ```\n *\n * @param name - Optional name of the app to return. If no name is\n *   provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The app corresponding to the provided app name.\n *   If no app name is provided, the default app is returned.\n *\n * @public\n */\nexport function getApp(name: string = DEFAULT_ENTRY_NAME): FirebaseApp {\n  const app = _apps.get(name);\n  if (!app && name === DEFAULT_ENTRY_NAME && getDefaultAppConfig()) {\n    return initializeApp();\n  }\n  if (!app) {\n    throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n  }\n\n  return app;\n}\n\n/**\n * A (read-only) array of all initialized apps.\n * @public\n */\nexport function getApps(): FirebaseApp[] {\n  return Array.from(_apps.values());\n}\n\n/**\n * Renders this app unusable and frees the resources of all associated\n * services.\n *\n * @example\n * ```javascript\n * deleteApp(app)\n *   .then(function() {\n *     console.log(\"App deleted successfully\");\n *   })\n *   .catch(function(error) {\n *     console.log(\"Error deleting app:\", error);\n *   });\n * ```\n *\n * @public\n */\nexport async function deleteApp(app: FirebaseApp): Promise<void> {\n  let cleanupProviders = false;\n  const name = app.name;\n  if (_apps.has(name)) {\n    cleanupProviders = true;\n    _apps.delete(name);\n  } else if (_serverApps.has(name)) {\n    const firebaseServerApp = app as FirebaseServerAppImpl;\n    if (firebaseServerApp.decRefCount() <= 0) {\n      _serverApps.delete(name);\n      cleanupProviders = true;\n    }\n  }\n\n  if (cleanupProviders) {\n    await Promise.all(\n      (app as FirebaseAppImpl).container\n        .getProviders()\n        .map(provider => provider.delete())\n    );\n    (app as FirebaseAppImpl).isDeleted = true;\n  }\n}\n\n/**\n * Registers a library's name and version for platform logging purposes.\n * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)\n * @param version - Current version of that library.\n * @param variant - Bundle variant, e.g., node, rn, etc.\n *\n * @public\n */\nexport function registerVersion(\n  libraryKeyOrName: string,\n  version: string,\n  variant?: string\n): void {\n  // TODO: We can use this check to whitelist strings when/if we set up\n  // a good whitelist system.\n  let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? libraryKeyOrName;\n  if (variant) {\n    library += `-${variant}`;\n  }\n  const libraryMismatch = library.match(/\\s|\\//);\n  const versionMismatch = version.match(/\\s|\\//);\n  if (libraryMismatch || versionMismatch) {\n    const warning = [\n      `Unable to register library \"${library}\" with version \"${version}\":`\n    ];\n    if (libraryMismatch) {\n      warning.push(\n        `library name \"${library}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    if (libraryMismatch && versionMismatch) {\n      warning.push('and');\n    }\n    if (versionMismatch) {\n      warning.push(\n        `version name \"${version}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    logger.warn(warning.join(' '));\n    return;\n  }\n  _registerComponent(\n    new Component(\n      `${library}-version` as Name,\n      () => ({ library, version }),\n      ComponentType.VERSION\n    )\n  );\n}\n\n/**\n * Sets log handler for all Firebase SDKs.\n * @param logCallback - An optional custom log handler that executes user code whenever\n * the Firebase SDK makes a logging call.\n *\n * @public\n */\nexport function onLog(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  if (logCallback !== null && typeof logCallback !== 'function') {\n    throw ERROR_FACTORY.create(AppError.INVALID_LOG_ARGUMENT);\n  }\n  setUserLogHandler(logCallback, options);\n}\n\n/**\n * Sets log level for all Firebase SDKs.\n *\n * All of the log types above the current log level are captured (i.e. if\n * you set the log level to `info`, errors are logged, but `debug` and\n * `verbose` logs are not).\n *\n * @public\n */\nexport function setLogLevel(logLevel: LogLevelString): void {\n  setLogLevelImpl(logLevel);\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { DBSchema, openDB, IDBPDatabase } from 'idb';\nimport { AppError, ERROR_FACTORY } from './errors';\nimport { FirebaseApp } from './public-types';\nimport { HeartbeatsInIndexedDB } from './types';\nimport { logger } from './logger';\n\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\n\ninterface AppDB extends DBSchema {\n  'firebase-heartbeat-store': {\n    key: string;\n    value: HeartbeatsInIndexedDB;\n  };\n}\n\nlet dbPromise: Promise<IDBPDatabase<AppDB>> | null = null;\nfunction getDbPromise(): Promise<IDBPDatabase<AppDB>> {\n  if (!dbPromise) {\n    dbPromise = openDB<AppDB>(DB_NAME, DB_VERSION, {\n      upgrade: (db, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            try {\n              db.createObjectStore(STORE_NAME);\n            } catch (e) {\n              // Safari/iOS browsers throw occasional exceptions on\n              // db.createObjectStore() that may be a bug. Avoid blocking\n              // the rest of the app functionality.\n              console.warn(e);\n            }\n        }\n      }\n    }).catch(e => {\n      throw ERROR_FACTORY.create(AppError.IDB_OPEN, {\n        originalErrorMessage: e.message\n      });\n    });\n  }\n  return dbPromise;\n}\n\nexport async function readHeartbeatsFromIndexedDB(\n  app: FirebaseApp\n): Promise<HeartbeatsInIndexedDB | undefined> {\n  try {\n    const db = await getDbPromise();\n    const tx = db.transaction(STORE_NAME);\n    const result = await tx.objectStore(STORE_NAME).get(computeKey(app));\n    // We already have the value but tx.done can throw,\n    // so we need to await it here to catch errors\n    await tx.done;\n    return result;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(AppError.IDB_GET, {\n        originalErrorMessage: (e as Error)?.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\n\nexport async function writeHeartbeatsToIndexedDB(\n  app: FirebaseApp,\n  heartbeatObject: HeartbeatsInIndexedDB\n): Promise<void> {\n  try {\n    const db = await getDbPromise();\n    const tx = db.transaction(STORE_NAME, 'readwrite');\n    const objectStore = tx.objectStore(STORE_NAME);\n    await objectStore.put(heartbeatObject, computeKey(app));\n    await tx.done;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(AppError.IDB_WRITE, {\n        originalErrorMessage: (e as Error)?.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\n\nfunction computeKey(app: FirebaseApp): string {\n  return `${app.name}!${app.options.appId}`;\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ComponentContainer } from '@firebase/component';\nimport {\n  base64urlEncodeWithoutPadding,\n  isIndexedDBAvailable,\n  validateIndexedDBOpenable\n} from '@firebase/util';\nimport {\n  readHeartbeatsFromIndexedDB,\n  writeHeartbeatsToIndexedDB\n} from './indexeddb';\nimport { FirebaseApp } from './public-types';\nimport {\n  HeartbeatsByUserAgent,\n  HeartbeatService,\n  HeartbeatsInIndexedDB,\n  HeartbeatStorage,\n  SingleDateHeartbeat\n} from './types';\nimport { logger } from './logger';\n\nconst MAX_HEADER_BYTES = 1024;\nexport const MAX_NUM_STORED_HEARTBEATS = 30;\n\nexport class HeartbeatServiceImpl implements HeartbeatService {\n  /**\n   * The persistence layer for heartbeats\n   * Leave public for easier testing.\n   */\n  _storage: HeartbeatStorageImpl;\n\n  /**\n   * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate\n   * the header string.\n   * Stores one record per date. This will be consolidated into the standard\n   * format of one record per user agent string before being sent as a header.\n   * Populated from indexedDB when the controller is instantiated and should\n   * be kept in sync with indexedDB.\n   * Leave public for easier testing.\n   */\n  _heartbeatsCache: HeartbeatsInIndexedDB | null = null;\n\n  /**\n   * the initialization promise for populating heartbeatCache.\n   * If getHeartbeatsHeader() is called before the promise resolves\n   * (heartbeatsCache == null), it should wait for this promise\n   * Leave public for easier testing.\n   */\n  _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;\n  constructor(private readonly container: ComponentContainer) {\n    const app = this.container.getProvider('app').getImmediate();\n    this._storage = new HeartbeatStorageImpl(app);\n    this._heartbeatsCachePromise = this._storage.read().then(result => {\n      this._heartbeatsCache = result;\n      return result;\n    });\n  }\n\n  /**\n   * Called to report a heartbeat. The function will generate\n   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it\n   * to IndexedDB.\n   * Note that we only store one heartbeat per day. So if a heartbeat for today is\n   * already logged, subsequent calls to this function in the same day will be ignored.\n   */\n  async triggerHeartbeat(): Promise<void> {\n    try {\n      const platformLogger = this.container\n        .getProvider('platform-logger')\n        .getImmediate();\n\n      // This is the \"Firebase user agent\" string from the platform logger\n      // service, not the browser user agent.\n      const agent = platformLogger.getPlatformInfoString();\n      const date = getUTCDateString();\n      if (this._heartbeatsCache?.heartbeats == null) {\n        this._heartbeatsCache = await this._heartbeatsCachePromise;\n        // If we failed to construct a heartbeats cache, then return immediately.\n        if (this._heartbeatsCache?.heartbeats == null) {\n          return;\n        }\n      }\n      // Do not store a heartbeat if one is already stored for this day\n      // or if a header has already been sent today.\n      if (\n        this._heartbeatsCache.lastSentHeartbeatDate === date ||\n        this._heartbeatsCache.heartbeats.some(\n          singleDateHeartbeat => singleDateHeartbeat.date === date\n        )\n      ) {\n        return;\n      } else {\n        // There is no entry for this date. Create one.\n        this._heartbeatsCache.heartbeats.push({ date, agent });\n\n        // If the number of stored heartbeats exceeds the maximum number of stored heartbeats, remove the heartbeat with the earliest date.\n        // Since this is executed each time a heartbeat is pushed, the limit can only be exceeded by one, so only one needs to be removed.\n        if (\n          this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS\n        ) {\n          const earliestHeartbeatIdx = getEarliestHeartbeatIdx(\n            this._heartbeatsCache.heartbeats\n          );\n          this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);\n        }\n      }\n\n      return this._storage.overwrite(this._heartbeatsCache);\n    } catch (e) {\n      logger.warn(e);\n    }\n  }\n\n  /**\n   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.\n   * It also clears all heartbeats from memory as well as in IndexedDB.\n   *\n   * NOTE: Consuming product SDKs should not send the header if this method\n   * returns an empty string.\n   */\n  async getHeartbeatsHeader(): Promise<string> {\n    try {\n      if (this._heartbeatsCache === null) {\n        await this._heartbeatsCachePromise;\n      }\n      // If it's still null or the array is empty, there is no data to send.\n      if (\n        this._heartbeatsCache?.heartbeats == null ||\n        this._heartbeatsCache.heartbeats.length === 0\n      ) {\n        return '';\n      }\n      const date = getUTCDateString();\n      // Extract as many heartbeats from the cache as will fit under the size limit.\n      const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(\n        this._heartbeatsCache.heartbeats\n      );\n      const headerString = base64urlEncodeWithoutPadding(\n        JSON.stringify({ version: 2, heartbeats: heartbeatsToSend })\n      );\n      // Store last sent date to prevent another being logged/sent for the same day.\n      this._heartbeatsCache.lastSentHeartbeatDate = date;\n      if (unsentEntries.length > 0) {\n        // Store any unsent entries if they exist.\n        this._heartbeatsCache.heartbeats = unsentEntries;\n        // This seems more likely than emptying the array (below) to lead to some odd state\n        // since the cache isn't empty and this will be called again on the next request,\n        // and is probably safest if we await it.\n        await this._storage.overwrite(this._heartbeatsCache);\n      } else {\n        this._heartbeatsCache.heartbeats = [];\n        // Do not wait for this, to reduce latency.\n        void this._storage.overwrite(this._heartbeatsCache);\n      }\n      return headerString;\n    } catch (e) {\n      logger.warn(e);\n      return '';\n    }\n  }\n}\n\nfunction getUTCDateString(): string {\n  const today = new Date();\n  // Returns date format 'YYYY-MM-DD'\n  return today.toISOString().substring(0, 10);\n}\n\nexport function extractHeartbeatsForHeader(\n  heartbeatsCache: SingleDateHeartbeat[],\n  maxSize = MAX_HEADER_BYTES\n): {\n  heartbeatsToSend: HeartbeatsByUserAgent[];\n  unsentEntries: SingleDateHeartbeat[];\n} {\n  // Heartbeats grouped by user agent in the standard format to be sent in\n  // the header.\n  const heartbeatsToSend: HeartbeatsByUserAgent[] = [];\n  // Single date format heartbeats that are not sent.\n  let unsentEntries = heartbeatsCache.slice();\n  for (const singleDateHeartbeat of heartbeatsCache) {\n    // Look for an existing entry with the same user agent.\n    const heartbeatEntry = heartbeatsToSend.find(\n      hb => hb.agent === singleDateHeartbeat.agent\n    );\n    if (!heartbeatEntry) {\n      // If no entry for this user agent exists, create one.\n      heartbeatsToSend.push({\n        agent: singleDateHeartbeat.agent,\n        dates: [singleDateHeartbeat.date]\n      });\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        // If the header would exceed max size, remove the added heartbeat\n        // entry and stop adding to the header.\n        heartbeatsToSend.pop();\n        break;\n      }\n    } else {\n      heartbeatEntry.dates.push(singleDateHeartbeat.date);\n      // If the header would exceed max size, remove the added date\n      // and stop adding to the header.\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        heartbeatEntry.dates.pop();\n        break;\n      }\n    }\n    // Pop unsent entry from queue. (Skipped if adding the entry exceeded\n    // quota and the loop breaks early.)\n    unsentEntries = unsentEntries.slice(1);\n  }\n  return {\n    heartbeatsToSend,\n    unsentEntries\n  };\n}\n\nexport class HeartbeatStorageImpl implements HeartbeatStorage {\n  private _canUseIndexedDBPromise: Promise<boolean>;\n  constructor(public app: FirebaseApp) {\n    this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();\n  }\n  async runIndexedDBEnvironmentCheck(): Promise<boolean> {\n    if (!isIndexedDBAvailable()) {\n      return false;\n    } else {\n      return validateIndexedDBOpenable()\n        .then(() => true)\n        .catch(() => false);\n    }\n  }\n  /**\n   * Read all heartbeats.\n   */\n  async read(): Promise<HeartbeatsInIndexedDB> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return { heartbeats: [] };\n    } else {\n      const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);\n      if (idbHeartbeatObject?.heartbeats) {\n        return idbHeartbeatObject;\n      } else {\n        return { heartbeats: [] };\n      }\n    }\n  }\n  // overwrite the storage with the provided heartbeats\n  async overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: heartbeatsObject.heartbeats\n      });\n    }\n  }\n  // add heartbeats\n  async add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: [\n          ...existingHeartbeatsObject.heartbeats,\n          ...heartbeatsObject.heartbeats\n        ]\n      });\n    }\n  }\n}\n\n/**\n * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped\n * in a platform logging header JSON object, stringified, and converted\n * to base 64.\n */\nexport function countBytes(heartbeatsCache: HeartbeatsByUserAgent[]): number {\n  // base64 has a restricted set of characters, all of which should be 1 byte.\n  return base64urlEncodeWithoutPadding(\n    // heartbeatsCache wrapper properties\n    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })\n  ).length;\n}\n\n/**\n * Returns the index of the heartbeat with the earliest date.\n * If the heartbeats array is empty, -1 is returned.\n */\nexport function getEarliestHeartbeatIdx(\n  heartbeats: SingleDateHeartbeat[]\n): number {\n  if (heartbeats.length === 0) {\n    return -1;\n  }\n\n  let earliestHeartbeatIdx = 0;\n  let earliestHeartbeatDate = heartbeats[0].date;\n\n  for (let i = 1; i < heartbeats.length; i++) {\n    if (heartbeats[i].date < earliestHeartbeatDate) {\n      earliestHeartbeatDate = heartbeats[i].date;\n      earliestHeartbeatIdx = i;\n    }\n  }\n\n  return earliestHeartbeatIdx;\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Component, ComponentType } from '@firebase/component';\nimport { PlatformLoggerServiceImpl } from './platformLoggerService';\nimport { name, version } from '../package.json';\nimport { _registerComponent } from './internal';\nimport { registerVersion } from './api';\nimport { HeartbeatServiceImpl } from './heartbeatService';\n\nexport function registerCoreComponents(variant?: string): void {\n  _registerComponent(\n    new Component(\n      'platform-logger',\n      container => new PlatformLoggerServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n  _registerComponent(\n    new Component(\n      'heartbeat',\n      container => new HeartbeatServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n\n  // Register `app` package.\n  registerVersion(name, version, variant);\n  // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n  // Register platform SDK identifier (no version).\n  registerVersion('fire-js', '');\n}\n", "/**\n * Firebase App\n *\n * @remarks This package coordinates the communication between the different Firebase components\n * @packageDocumentation\n */\n\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { registerCoreComponents } from './registerCoreComponents';\n\nexport * from './api';\nexport * from './internal';\nexport * from './public-types';\n\nregisterCoreComponents('__RUNTIME_ENV__');\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * An enum of factors that may be used for multifactor authentication.\n *\n * @public\n */\nexport const FactorId = {\n  /** Phone as second factor */\n  PHONE: 'phone',\n  TOTP: 'totp'\n} as const;\n\n/**\n * Enumeration of supported providers.\n *\n * @public\n */\nexport const ProviderId = {\n  /** Facebook provider ID */\n  FACEBOOK: 'facebook.com',\n  /** GitHub provider ID */\n  GITHUB: 'github.com',\n  /** Google provider ID */\n  GOOGLE: 'google.com',\n  /** Password provider */\n  PASSWORD: 'password',\n  /** Phone provider */\n  PHONE: 'phone',\n  /** Twitter provider ID */\n  TWITTER: 'twitter.com'\n} as const;\n\n/**\n * Enumeration of supported sign-in methods.\n *\n * @public\n */\nexport const SignInMethod = {\n  /** Email link sign in method */\n  EMAIL_LINK: 'emailLink',\n  /** Email/password sign in method */\n  EMAIL_PASSWORD: 'password',\n  /** Facebook sign in method */\n  FACEBOOK: 'facebook.com',\n  /** GitHub sign in method */\n  GITHUB: 'github.com',\n  /** Google sign in method */\n  GOOGLE: 'google.com',\n  /** Phone sign in method */\n  PHONE: 'phone',\n  /** Twitter sign in method */\n  TWITTER: 'twitter.com'\n} as const;\n\n/**\n * Enumeration of supported operation types.\n *\n * @public\n */\nexport const OperationType = {\n  /** Operation involving linking an additional provider to an already signed-in user. */\n  LINK: 'link',\n  /** Operation involving using a provider to reauthenticate an already signed-in user. */\n  REAUTHENTICATE: 'reauthenticate',\n  /** Operation involving signing in a user. */\n  SIGN_IN: 'signIn'\n} as const;\n\n/**\n * An enumeration of the possible email action types.\n *\n * @public\n */\nexport const ActionCodeOperation = {\n  /** The email link sign-in action. */\n  EMAIL_SIGNIN: 'EMAIL_SIGNIN',\n  /** The password reset action. */\n  PASSWORD_RESET: 'PASSWORD_RESET',\n  /** The email revocation action. */\n  RECOVER_EMAIL: 'RECOVER_EMAIL',\n  /** The revert second factor addition email action. */\n  REVERT_SECOND_FACTOR_ADDITION: 'REVERT_SECOND_FACTOR_ADDITION',\n  /** The revert second factor addition email action. */\n  VERIFY_AND_CHANGE_EMAIL: 'VERIFY_AND_CHANGE_EMAIL',\n  /** The email verification action. */\n  VERIFY_EMAIL: 'VERIFY_EMAIL'\n} as const;\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorMap, User } from '../model/public_types';\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nimport { IdTokenMfaResponse } from '../api/authentication/mfa';\nimport { AppName } from '../model/auth';\nimport { AuthCredential } from './credentials';\n\n/**\n * Enumeration of Firebase Auth error codes.\n *\n * @internal\n */\nexport const enum AuthErrorCode {\n  ADMIN_ONLY_OPERATION = 'admin-restricted-operation',\n  ARGUMENT_ERROR = 'argument-error',\n  APP_NOT_AUTHORIZED = 'app-not-authorized',\n  APP_NOT_INSTALLED = 'app-not-installed',\n  CAPTCHA_CHECK_FAILED = 'captcha-check-failed',\n  CODE_EXPIRED = 'code-expired',\n  CORDOVA_NOT_READY = 'cordova-not-ready',\n  CORS_UNSUPPORTED = 'cors-unsupported',\n  CREDENTIAL_ALREADY_IN_USE = 'credential-already-in-use',\n  CREDENTIAL_MISMATCH = 'custom-token-mismatch',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN = 'requires-recent-login',\n  DEPENDENT_SDK_INIT_BEFORE_AUTH = 'dependent-sdk-initialized-before-auth',\n  DYNAMIC_LINK_NOT_ACTIVATED = 'dynamic-link-not-activated',\n  EMAIL_CHANGE_NEEDS_VERIFICATION = 'email-change-needs-verification',\n  EMAIL_EXISTS = 'email-already-in-use',\n  EMULATOR_CONFIG_FAILED = 'emulator-config-failed',\n  EXPIRED_OOB_CODE = 'expired-action-code',\n  EXPIRED_POPUP_REQUEST = 'cancelled-popup-request',\n  INTERNAL_ERROR = 'internal-error',\n  INVALID_API_KEY = 'invalid-api-key',\n  INVALID_APP_CREDENTIAL = 'invalid-app-credential',\n  INVALID_APP_ID = 'invalid-app-id',\n  INVALID_AUTH = 'invalid-user-token',\n  INVALID_AUTH_EVENT = 'invalid-auth-event',\n  INVALID_CERT_HASH = 'invalid-cert-hash',\n  INVALID_CODE = 'invalid-verification-code',\n  INVALID_CONTINUE_URI = 'invalid-continue-uri',\n  INVALID_CORDOVA_CONFIGURATION = 'invalid-cordova-configuration',\n  INVALID_CUSTOM_TOKEN = 'invalid-custom-token',\n  INVALID_DYNAMIC_LINK_DOMAIN = 'invalid-dynamic-link-domain',\n  INVALID_EMAIL = 'invalid-email',\n  INVALID_EMULATOR_SCHEME = 'invalid-emulator-scheme',\n  INVALID_CREDENTIAL = 'invalid-credential',\n  INVALID_MESSAGE_PAYLOAD = 'invalid-message-payload',\n  INVALID_MFA_SESSION = 'invalid-multi-factor-session',\n  INVALID_OAUTH_CLIENT_ID = 'invalid-oauth-client-id',\n  INVALID_OAUTH_PROVIDER = 'invalid-oauth-provider',\n  INVALID_OOB_CODE = 'invalid-action-code',\n  INVALID_ORIGIN = 'unauthorized-domain',\n  INVALID_PASSWORD = 'wrong-password',\n  INVALID_PERSISTENCE = 'invalid-persistence-type',\n  INVALID_PHONE_NUMBER = 'invalid-phone-number',\n  INVALID_PROVIDER_ID = 'invalid-provider-id',\n  INVALID_RECIPIENT_EMAIL = 'invalid-recipient-email',\n  INVALID_SENDER = 'invalid-sender',\n  INVALID_SESSION_INFO = 'invalid-verification-id',\n  INVALID_TENANT_ID = 'invalid-tenant-id',\n  LOGIN_BLOCKED = 'login-blocked',\n  MFA_INFO_NOT_FOUND = 'multi-factor-info-not-found',\n  MFA_REQUIRED = 'multi-factor-auth-required',\n  MISSING_ANDROID_PACKAGE_NAME = 'missing-android-pkg-name',\n  MISSING_APP_CREDENTIAL = 'missing-app-credential',\n  MISSING_AUTH_DOMAIN = 'auth-domain-config-required',\n  MISSING_CODE = 'missing-verification-code',\n  MISSING_CONTINUE_URI = 'missing-continue-uri',\n  MISSING_IFRAME_START = 'missing-iframe-start',\n  MISSING_IOS_BUNDLE_ID = 'missing-ios-bundle-id',\n  MISSING_OR_INVALID_NONCE = 'missing-or-invalid-nonce',\n  MISSING_MFA_INFO = 'missing-multi-factor-info',\n  MISSING_MFA_SESSION = 'missing-multi-factor-session',\n  MISSING_PHONE_NUMBER = 'missing-phone-number',\n  MISSING_PASSWORD = 'missing-password',\n  MISSING_SESSION_INFO = 'missing-verification-id',\n  MODULE_DESTROYED = 'app-deleted',\n  NEED_CONFIRMATION = 'account-exists-with-different-credential',\n  NETWORK_REQUEST_FAILED = 'network-request-failed',\n  NULL_USER = 'null-user',\n  NO_AUTH_EVENT = 'no-auth-event',\n  NO_SUCH_PROVIDER = 'no-such-provider',\n  OPERATION_NOT_ALLOWED = 'operation-not-allowed',\n  OPERATION_NOT_SUPPORTED = 'operation-not-supported-in-this-environment',\n  POPUP_BLOCKED = 'popup-blocked',\n  POPUP_CLOSED_BY_USER = 'popup-closed-by-user',\n  PROVIDER_ALREADY_LINKED = 'provider-already-linked',\n  QUOTA_EXCEEDED = 'quota-exceeded',\n  REDIRECT_CANCELLED_BY_USER = 'redirect-cancelled-by-user',\n  REDIRECT_OPERATION_PENDING = 'redirect-operation-pending',\n  REJECTED_CREDENTIAL = 'rejected-credential',\n  SECOND_FACTOR_ALREADY_ENROLLED = 'second-factor-already-in-use',\n  SECOND_FACTOR_LIMIT_EXCEEDED = 'maximum-second-factor-count-exceeded',\n  TENANT_ID_MISMATCH = 'tenant-id-mismatch',\n  TIMEOUT = 'timeout',\n  TOKEN_EXPIRED = 'user-token-expired',\n  TOO_MANY_ATTEMPTS_TRY_LATER = 'too-many-requests',\n  UNAUTHORIZED_DOMAIN = 'unauthorized-continue-uri',\n  UNSUPPORTED_FIRST_FACTOR = 'unsupported-first-factor',\n  UNSUPPORTED_PERSISTENCE = 'unsupported-persistence-type',\n  UNSUPPORTED_TENANT_OPERATION = 'unsupported-tenant-operation',\n  UNVERIFIED_EMAIL = 'unverified-email',\n  USER_CANCELLED = 'user-cancelled',\n  USER_DELETED = 'user-not-found',\n  USER_DISABLED = 'user-disabled',\n  USER_MISMATCH = 'user-mismatch',\n  USER_SIGNED_OUT = 'user-signed-out',\n  WEAK_PASSWORD = 'weak-password',\n  WEB_STORAGE_UNSUPPORTED = 'web-storage-unsupported',\n  ALREADY_INITIALIZED = 'already-initialized',\n  RECAPTCHA_NOT_ENABLED = 'recaptcha-not-enabled',\n  MISSING_RECAPTCHA_TOKEN = 'missing-recaptcha-token',\n  INVALID_RECAPTCHA_TOKEN = 'invalid-recaptcha-token',\n  INVALID_RECAPTCHA_ACTION = 'invalid-recaptcha-action',\n  MISSING_CLIENT_TYPE = 'missing-client-type',\n  MISSING_RECAPTCHA_VERSION = 'missing-recaptcha-version',\n  INVALID_RECAPTCHA_VERSION = 'invalid-recaptcha-version',\n  INVALID_REQ_TYPE = 'invalid-req-type',\n  UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION = 'unsupported-password-policy-schema-version',\n  PASSWORD_DOES_NOT_MEET_REQUIREMENTS = 'password-does-not-meet-requirements',\n  INVALID_HOSTING_LINK_DOMAIN = 'invalid-hosting-link-domain'\n}\n\nfunction _debugErrorMap(): ErrorMap<AuthErrorCode> {\n  return {\n    [AuthErrorCode.ADMIN_ONLY_OPERATION]:\n      'This operation is restricted to administrators only.',\n    [AuthErrorCode.ARGUMENT_ERROR]: '',\n    [AuthErrorCode.APP_NOT_AUTHORIZED]:\n      \"This app, identified by the domain where it's hosted, is not \" +\n      'authorized to use Firebase Authentication with the provided API key. ' +\n      'Review your key configuration in the Google API console.',\n    [AuthErrorCode.APP_NOT_INSTALLED]:\n      'The requested mobile application corresponding to the identifier (' +\n      'Android package name or iOS bundle ID) provided is not installed on ' +\n      'this device.',\n    [AuthErrorCode.CAPTCHA_CHECK_FAILED]:\n      'The reCAPTCHA response token provided is either invalid, expired, ' +\n      'already used or the domain associated with it does not match the list ' +\n      'of whitelisted domains.',\n    [AuthErrorCode.CODE_EXPIRED]:\n      'The SMS code has expired. Please re-send the verification code to try ' +\n      'again.',\n    [AuthErrorCode.CORDOVA_NOT_READY]: 'Cordova framework is not ready.',\n    [AuthErrorCode.CORS_UNSUPPORTED]: 'This browser is not supported.',\n    [AuthErrorCode.CREDENTIAL_ALREADY_IN_USE]:\n      'This credential is already associated with a different user account.',\n    [AuthErrorCode.CREDENTIAL_MISMATCH]:\n      'The custom token corresponds to a different audience.',\n    [AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN]:\n      'This operation is sensitive and requires recent authentication. Log in ' +\n      'again before retrying this request.',\n    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]:\n      'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +\n      'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +\n      'starting any other Firebase SDK.',\n    [AuthErrorCode.DYNAMIC_LINK_NOT_ACTIVATED]:\n      'Please activate Dynamic Links in the Firebase Console and agree to the terms and ' +\n      'conditions.',\n    [AuthErrorCode.EMAIL_CHANGE_NEEDS_VERIFICATION]:\n      'Multi-factor users must always have a verified email.',\n    [AuthErrorCode.EMAIL_EXISTS]:\n      'The email address is already in use by another account.',\n    [AuthErrorCode.EMULATOR_CONFIG_FAILED]:\n      'Auth instance has already been used to make a network call. Auth can ' +\n      'no longer be configured to use the emulator. Try calling ' +\n      '\"connectAuthEmulator()\" sooner.',\n    [AuthErrorCode.EXPIRED_OOB_CODE]: 'The action code has expired.',\n    [AuthErrorCode.EXPIRED_POPUP_REQUEST]:\n      'This operation has been cancelled due to another conflicting popup being opened.',\n    [AuthErrorCode.INTERNAL_ERROR]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.INVALID_APP_CREDENTIAL]:\n      'The phone verification request contains an invalid application verifier.' +\n      ' The reCAPTCHA token response is either invalid or expired.',\n    [AuthErrorCode.INVALID_APP_ID]:\n      'The mobile app identifier is not registered for the current project.',\n    [AuthErrorCode.INVALID_AUTH]:\n      \"This user's credential isn't valid for this project. This can happen \" +\n      \"if the user's token has been tampered with, or if the user isn't for \" +\n      'the project associated with this API key.',\n    [AuthErrorCode.INVALID_AUTH_EVENT]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.INVALID_CODE]:\n      'The SMS verification code used to create the phone auth credential is ' +\n      'invalid. Please resend the verification code sms and be sure to use the ' +\n      'verification code provided by the user.',\n    [AuthErrorCode.INVALID_CONTINUE_URI]:\n      'The continue URL provided in the request is invalid.',\n    [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]:\n      'The following Cordova plugins must be installed to enable OAuth sign-in: ' +\n      'cordova-plugin-buildinfo, cordova-universal-links-plugin, ' +\n      'cordova-plugin-browsertab, cordova-plugin-inappbrowser and ' +\n      'cordova-plugin-customurlscheme.',\n    [AuthErrorCode.INVALID_CUSTOM_TOKEN]:\n      'The custom token format is incorrect. Please check the documentation.',\n    [AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN]:\n      'The provided dynamic link domain is not configured or authorized for the current project.',\n    [AuthErrorCode.INVALID_EMAIL]: 'The email address is badly formatted.',\n    [AuthErrorCode.INVALID_EMULATOR_SCHEME]:\n      'Emulator URL must start with a valid scheme (http:// or https://).',\n    [AuthErrorCode.INVALID_API_KEY]:\n      'Your API key is invalid, please check you have copied it correctly.',\n    [AuthErrorCode.INVALID_CERT_HASH]:\n      'The SHA-1 certificate hash provided is invalid.',\n    [AuthErrorCode.INVALID_CREDENTIAL]:\n      'The supplied auth credential is incorrect, malformed or has expired.',\n    [AuthErrorCode.INVALID_MESSAGE_PAYLOAD]:\n      'The email template corresponding to this action contains invalid characters in its message. ' +\n      'Please fix by going to the Auth email templates section in the Firebase Console.',\n    [AuthErrorCode.INVALID_MFA_SESSION]:\n      'The request does not contain a valid proof of first factor successful sign-in.',\n    [AuthErrorCode.INVALID_OAUTH_PROVIDER]:\n      'EmailAuthProvider is not supported for this operation. This operation ' +\n      'only supports OAuth providers.',\n    [AuthErrorCode.INVALID_OAUTH_CLIENT_ID]:\n      'The OAuth client ID provided is either invalid or does not match the ' +\n      'specified API key.',\n    [AuthErrorCode.INVALID_ORIGIN]:\n      'This domain is not authorized for OAuth operations for your Firebase ' +\n      'project. Edit the list of authorized domains from the Firebase console.',\n    [AuthErrorCode.INVALID_OOB_CODE]:\n      'The action code is invalid. This can happen if the code is malformed, ' +\n      'expired, or has already been used.',\n    [AuthErrorCode.INVALID_PASSWORD]:\n      'The password is invalid or the user does not have a password.',\n    [AuthErrorCode.INVALID_PERSISTENCE]:\n      'The specified persistence type is invalid. It can only be local, session or none.',\n    [AuthErrorCode.INVALID_PHONE_NUMBER]:\n      'The format of the phone number provided is incorrect. Please enter the ' +\n      'phone number in a format that can be parsed into E.164 format. E.164 ' +\n      'phone numbers are written in the format [+][country code][subscriber ' +\n      'number including area code].',\n    [AuthErrorCode.INVALID_PROVIDER_ID]:\n      'The specified provider ID is invalid.',\n    [AuthErrorCode.INVALID_RECIPIENT_EMAIL]:\n      'The email corresponding to this action failed to send as the provided ' +\n      'recipient email address is invalid.',\n    [AuthErrorCode.INVALID_SENDER]:\n      'The email template corresponding to this action contains an invalid sender email or name. ' +\n      'Please fix by going to the Auth email templates section in the Firebase Console.',\n    [AuthErrorCode.INVALID_SESSION_INFO]:\n      'The verification ID used to create the phone auth credential is invalid.',\n    [AuthErrorCode.INVALID_TENANT_ID]:\n      \"The Auth instance's tenant ID is invalid.\",\n    [AuthErrorCode.LOGIN_BLOCKED]:\n      'Login blocked by user-provided method: {$originalMessage}',\n    [AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME]:\n      'An Android Package Name must be provided if the Android App is required to be installed.',\n    [AuthErrorCode.MISSING_AUTH_DOMAIN]:\n      'Be sure to include authDomain when calling firebase.initializeApp(), ' +\n      'by following the instructions in the Firebase console.',\n    [AuthErrorCode.MISSING_APP_CREDENTIAL]:\n      'The phone verification request is missing an application verifier ' +\n      'assertion. A reCAPTCHA response token needs to be provided.',\n    [AuthErrorCode.MISSING_CODE]:\n      'The phone auth credential was created with an empty SMS verification code.',\n    [AuthErrorCode.MISSING_CONTINUE_URI]:\n      'A continue URL must be provided in the request.',\n    [AuthErrorCode.MISSING_IFRAME_START]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.MISSING_IOS_BUNDLE_ID]:\n      'An iOS Bundle ID must be provided if an App Store ID is provided.',\n    [AuthErrorCode.MISSING_OR_INVALID_NONCE]:\n      'The request does not contain a valid nonce. This can occur if the ' +\n      'SHA-256 hash of the provided raw nonce does not match the hashed nonce ' +\n      'in the ID token payload.',\n    [AuthErrorCode.MISSING_PASSWORD]: 'A non-empty password must be provided',\n    [AuthErrorCode.MISSING_MFA_INFO]:\n      'No second factor identifier is provided.',\n    [AuthErrorCode.MISSING_MFA_SESSION]:\n      'The request is missing proof of first factor successful sign-in.',\n    [AuthErrorCode.MISSING_PHONE_NUMBER]:\n      'To send verification codes, provide a phone number for the recipient.',\n    [AuthErrorCode.MISSING_SESSION_INFO]:\n      'The phone auth credential was created with an empty verification ID.',\n    [AuthErrorCode.MODULE_DESTROYED]:\n      'This instance of FirebaseApp has been deleted.',\n    [AuthErrorCode.MFA_INFO_NOT_FOUND]:\n      'The user does not have a second factor matching the identifier provided.',\n    [AuthErrorCode.MFA_REQUIRED]:\n      'Proof of ownership of a second factor is required to complete sign-in.',\n    [AuthErrorCode.NEED_CONFIRMATION]:\n      'An account already exists with the same email address but different ' +\n      'sign-in credentials. Sign in using a provider associated with this ' +\n      'email address.',\n    [AuthErrorCode.NETWORK_REQUEST_FAILED]:\n      'A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.',\n    [AuthErrorCode.NO_AUTH_EVENT]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.NO_SUCH_PROVIDER]:\n      'User was not linked to an account with the given provider.',\n    [AuthErrorCode.NULL_USER]:\n      'A null user object was provided as the argument for an operation which ' +\n      'requires a non-null user object.',\n    [AuthErrorCode.OPERATION_NOT_ALLOWED]:\n      'The given sign-in provider is disabled for this Firebase project. ' +\n      'Enable it in the Firebase console, under the sign-in method tab of the ' +\n      'Auth section.',\n    [AuthErrorCode.OPERATION_NOT_SUPPORTED]:\n      'This operation is not supported in the environment this application is ' +\n      'running on. \"location.protocol\" must be http, https or chrome-extension' +\n      ' and web storage must be enabled.',\n    [AuthErrorCode.POPUP_BLOCKED]:\n      'Unable to establish a connection with the popup. It may have been blocked by the browser.',\n    [AuthErrorCode.POPUP_CLOSED_BY_USER]:\n      'The popup has been closed by the user before finalizing the operation.',\n    [AuthErrorCode.PROVIDER_ALREADY_LINKED]:\n      'User can only be linked to one identity for the given provider.',\n    [AuthErrorCode.QUOTA_EXCEEDED]:\n      \"The project's quota for this operation has been exceeded.\",\n    [AuthErrorCode.REDIRECT_CANCELLED_BY_USER]:\n      'The redirect operation has been cancelled by the user before finalizing.',\n    [AuthErrorCode.REDIRECT_OPERATION_PENDING]:\n      'A redirect sign-in operation is already pending.',\n    [AuthErrorCode.REJECTED_CREDENTIAL]:\n      'The request contains malformed or mismatching credentials.',\n    [AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED]:\n      'The second factor is already enrolled on this account.',\n    [AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED]:\n      'The maximum allowed number of second factors on a user has been exceeded.',\n    [AuthErrorCode.TENANT_ID_MISMATCH]:\n      \"The provided tenant ID does not match the Auth instance's tenant ID\",\n    [AuthErrorCode.TIMEOUT]: 'The operation has timed out.',\n    [AuthErrorCode.TOKEN_EXPIRED]:\n      \"The user's credential is no longer valid. The user must sign in again.\",\n    [AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER]:\n      'We have blocked all requests from this device due to unusual activity. ' +\n      'Try again later.',\n    [AuthErrorCode.UNAUTHORIZED_DOMAIN]:\n      'The domain of the continue URL is not whitelisted.  Please whitelist ' +\n      'the domain in the Firebase console.',\n    [AuthErrorCode.UNSUPPORTED_FIRST_FACTOR]:\n      'Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.',\n    [AuthErrorCode.UNSUPPORTED_PERSISTENCE]:\n      'The current environment does not support the specified persistence type.',\n    [AuthErrorCode.UNSUPPORTED_TENANT_OPERATION]:\n      'This operation is not supported in a multi-tenant context.',\n    [AuthErrorCode.UNVERIFIED_EMAIL]:\n      'The operation requires a verified email.',\n    [AuthErrorCode.USER_CANCELLED]:\n      'The user did not grant your application the permissions it requested.',\n    [AuthErrorCode.USER_DELETED]:\n      'There is no user record corresponding to this identifier. The user may ' +\n      'have been deleted.',\n    [AuthErrorCode.USER_DISABLED]:\n      'The user account has been disabled by an administrator.',\n    [AuthErrorCode.USER_MISMATCH]:\n      'The supplied credentials do not correspond to the previously signed in user.',\n    [AuthErrorCode.USER_SIGNED_OUT]: '',\n    [AuthErrorCode.WEAK_PASSWORD]:\n      'The password must be 6 characters long or more.',\n    [AuthErrorCode.WEB_STORAGE_UNSUPPORTED]:\n      'This browser is not supported or 3rd party cookies and data may be disabled.',\n    [AuthErrorCode.ALREADY_INITIALIZED]:\n      'initializeAuth() has already been called with ' +\n      'different options. To avoid this error, call initializeAuth() with the ' +\n      'same options as when it was originally called, or call getAuth() to return the' +\n      ' already initialized instance.',\n    [AuthErrorCode.MISSING_RECAPTCHA_TOKEN]:\n      'The reCAPTCHA token is missing when sending request to the backend.',\n    [AuthErrorCode.INVALID_RECAPTCHA_TOKEN]:\n      'The reCAPTCHA token is invalid when sending request to the backend.',\n    [AuthErrorCode.INVALID_RECAPTCHA_ACTION]:\n      'The reCAPTCHA action is invalid when sending request to the backend.',\n    [AuthErrorCode.RECAPTCHA_NOT_ENABLED]:\n      'reCAPTCHA Enterprise integration is not enabled for this project.',\n    [AuthErrorCode.MISSING_CLIENT_TYPE]:\n      'The reCAPTCHA client type is missing when sending request to the backend.',\n    [AuthErrorCode.MISSING_RECAPTCHA_VERSION]:\n      'The reCAPTCHA version is missing when sending request to the backend.',\n    [AuthErrorCode.INVALID_REQ_TYPE]: 'Invalid request parameters.',\n    [AuthErrorCode.INVALID_RECAPTCHA_VERSION]:\n      'The reCAPTCHA version is invalid when sending request to the backend.',\n    [AuthErrorCode.UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION]:\n      'The password policy received from the backend uses a schema version that is not supported by this version of the Firebase SDK.',\n    [AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS]:\n      'The password does not meet the requirements.',\n    [AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN]:\n      'The provided Hosting link domain is not configured in Firebase Hosting or is not owned by ' +\n      'the current project. This cannot be a default Hosting domain (`web.app` or `firebaseapp.com`).'\n  };\n}\n\nexport interface ErrorMapRetriever extends AuthErrorMap {\n  (): ErrorMap<AuthErrorCode>;\n}\n\nfunction _prodErrorMap(): ErrorMap<AuthErrorCode> {\n  // We will include this one message in the prod error map since by the very\n  // nature of this error, developers will never be able to see the message\n  // using the debugErrorMap (which is installed during auth initialization).\n  return {\n    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]:\n      'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +\n      'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +\n      'starting any other Firebase SDK.'\n  } as ErrorMap<AuthErrorCode>;\n}\n\n/**\n * A verbose error map with detailed descriptions for most error codes.\n *\n * See discussion at {@link AuthErrorMap}\n *\n * @public\n */\nexport const debugErrorMap: AuthErrorMap = _debugErrorMap;\n\n/**\n * A minimal error map with all verbose error messages stripped.\n *\n * See discussion at {@link AuthErrorMap}\n *\n * @public\n */\nexport const prodErrorMap: AuthErrorMap = _prodErrorMap;\n\nexport interface NamedErrorParams {\n  appName: AppName;\n  credential?: AuthCredential;\n  email?: string;\n  phoneNumber?: string;\n  tenantId?: string;\n  user?: User;\n  _serverResponse?: object;\n}\n\n/**\n * @internal\n */\ntype GenericAuthErrorParams = {\n  [key in Exclude<\n    AuthErrorCode,\n    | AuthErrorCode.ARGUMENT_ERROR\n    | AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH\n    | AuthErrorCode.INTERNAL_ERROR\n    | AuthErrorCode.MFA_REQUIRED\n    | AuthErrorCode.NO_AUTH_EVENT\n    | AuthErrorCode.OPERATION_NOT_SUPPORTED\n  >]: {\n    appName?: AppName;\n    email?: string;\n    phoneNumber?: string;\n    message?: string;\n  };\n};\n\n/**\n * @internal\n */\nexport interface AuthErrorParams extends GenericAuthErrorParams {\n  [AuthErrorCode.ARGUMENT_ERROR]: { appName?: AppName };\n  [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]: { appName?: AppName };\n  [AuthErrorCode.INTERNAL_ERROR]: { appName?: AppName };\n  [AuthErrorCode.LOGIN_BLOCKED]: {\n    appName?: AppName;\n    originalMessage?: string;\n  };\n  [AuthErrorCode.OPERATION_NOT_SUPPORTED]: { appName?: AppName };\n  [AuthErrorCode.NO_AUTH_EVENT]: { appName?: AppName };\n  [AuthErrorCode.MFA_REQUIRED]: {\n    appName: AppName;\n    _serverResponse: IdTokenMfaResponse;\n  };\n  [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]: {\n    appName: AppName;\n    missingPlugin?: string;\n  };\n}\n\nexport const _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory<\n  AuthErrorCode,\n  AuthErrorParams\n>('auth', 'Firebase', _prodErrorMap());\n\n/**\n * A map of potential `Auth` error codes, for easier comparison with errors\n * thrown by the SDK.\n *\n * @remarks\n * Note that you can't tree-shake individual keys\n * in the map, so by using the map you might substantially increase your\n * bundle size.\n *\n * @public\n */\nexport const AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY = {\n  ADMIN_ONLY_OPERATION: 'auth/admin-restricted-operation',\n  ARGUMENT_ERROR: 'auth/argument-error',\n  APP_NOT_AUTHORIZED: 'auth/app-not-authorized',\n  APP_NOT_INSTALLED: 'auth/app-not-installed',\n  CAPTCHA_CHECK_FAILED: 'auth/captcha-check-failed',\n  CODE_EXPIRED: 'auth/code-expired',\n  CORDOVA_NOT_READY: 'auth/cordova-not-ready',\n  CORS_UNSUPPORTED: 'auth/cors-unsupported',\n  CREDENTIAL_ALREADY_IN_USE: 'auth/credential-already-in-use',\n  CREDENTIAL_MISMATCH: 'auth/custom-token-mismatch',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN: 'auth/requires-recent-login',\n  DEPENDENT_SDK_INIT_BEFORE_AUTH: 'auth/dependent-sdk-initialized-before-auth',\n  DYNAMIC_LINK_NOT_ACTIVATED: 'auth/dynamic-link-not-activated',\n  EMAIL_CHANGE_NEEDS_VERIFICATION: 'auth/email-change-needs-verification',\n  EMAIL_EXISTS: 'auth/email-already-in-use',\n  EMULATOR_CONFIG_FAILED: 'auth/emulator-config-failed',\n  EXPIRED_OOB_CODE: 'auth/expired-action-code',\n  EXPIRED_POPUP_REQUEST: 'auth/cancelled-popup-request',\n  INTERNAL_ERROR: 'auth/internal-error',\n  INVALID_API_KEY: 'auth/invalid-api-key',\n  INVALID_APP_CREDENTIAL: 'auth/invalid-app-credential',\n  INVALID_APP_ID: 'auth/invalid-app-id',\n  INVALID_AUTH: 'auth/invalid-user-token',\n  INVALID_AUTH_EVENT: 'auth/invalid-auth-event',\n  INVALID_CERT_HASH: 'auth/invalid-cert-hash',\n  INVALID_CODE: 'auth/invalid-verification-code',\n  INVALID_CONTINUE_URI: 'auth/invalid-continue-uri',\n  INVALID_CORDOVA_CONFIGURATION: 'auth/invalid-cordova-configuration',\n  INVALID_CUSTOM_TOKEN: 'auth/invalid-custom-token',\n  INVALID_DYNAMIC_LINK_DOMAIN: 'auth/invalid-dynamic-link-domain',\n  INVALID_EMAIL: 'auth/invalid-email',\n  INVALID_EMULATOR_SCHEME: 'auth/invalid-emulator-scheme',\n  INVALID_IDP_RESPONSE: 'auth/invalid-credential',\n  INVALID_LOGIN_CREDENTIALS: 'auth/invalid-credential',\n  INVALID_MESSAGE_PAYLOAD: 'auth/invalid-message-payload',\n  INVALID_MFA_SESSION: 'auth/invalid-multi-factor-session',\n  INVALID_OAUTH_CLIENT_ID: 'auth/invalid-oauth-client-id',\n  INVALID_OAUTH_PROVIDER: 'auth/invalid-oauth-provider',\n  INVALID_OOB_CODE: 'auth/invalid-action-code',\n  INVALID_ORIGIN: 'auth/unauthorized-domain',\n  INVALID_PASSWORD: 'auth/wrong-password',\n  INVALID_PERSISTENCE: 'auth/invalid-persistence-type',\n  INVALID_PHONE_NUMBER: 'auth/invalid-phone-number',\n  INVALID_PROVIDER_ID: 'auth/invalid-provider-id',\n  INVALID_RECIPIENT_EMAIL: 'auth/invalid-recipient-email',\n  INVALID_SENDER: 'auth/invalid-sender',\n  INVALID_SESSION_INFO: 'auth/invalid-verification-id',\n  INVALID_TENANT_ID: 'auth/invalid-tenant-id',\n  MFA_INFO_NOT_FOUND: 'auth/multi-factor-info-not-found',\n  MFA_REQUIRED: 'auth/multi-factor-auth-required',\n  MISSING_ANDROID_PACKAGE_NAME: 'auth/missing-android-pkg-name',\n  MISSING_APP_CREDENTIAL: 'auth/missing-app-credential',\n  MISSING_AUTH_DOMAIN: 'auth/auth-domain-config-required',\n  MISSING_CODE: 'auth/missing-verification-code',\n  MISSING_CONTINUE_URI: 'auth/missing-continue-uri',\n  MISSING_IFRAME_START: 'auth/missing-iframe-start',\n  MISSING_IOS_BUNDLE_ID: 'auth/missing-ios-bundle-id',\n  MISSING_OR_INVALID_NONCE: 'auth/missing-or-invalid-nonce',\n  MISSING_MFA_INFO: 'auth/missing-multi-factor-info',\n  MISSING_MFA_SESSION: 'auth/missing-multi-factor-session',\n  MISSING_PHONE_NUMBER: 'auth/missing-phone-number',\n  MISSING_PASSWORD: 'auth/missing-password',\n  MISSING_SESSION_INFO: 'auth/missing-verification-id',\n  MODULE_DESTROYED: 'auth/app-deleted',\n  NEED_CONFIRMATION: 'auth/account-exists-with-different-credential',\n  NETWORK_REQUEST_FAILED: 'auth/network-request-failed',\n  NULL_USER: 'auth/null-user',\n  NO_AUTH_EVENT: 'auth/no-auth-event',\n  NO_SUCH_PROVIDER: 'auth/no-such-provider',\n  OPERATION_NOT_ALLOWED: 'auth/operation-not-allowed',\n  OPERATION_NOT_SUPPORTED: 'auth/operation-not-supported-in-this-environment',\n  POPUP_BLOCKED: 'auth/popup-blocked',\n  POPUP_CLOSED_BY_USER: 'auth/popup-closed-by-user',\n  PROVIDER_ALREADY_LINKED: 'auth/provider-already-linked',\n  QUOTA_EXCEEDED: 'auth/quota-exceeded',\n  REDIRECT_CANCELLED_BY_USER: 'auth/redirect-cancelled-by-user',\n  REDIRECT_OPERATION_PENDING: 'auth/redirect-operation-pending',\n  REJECTED_CREDENTIAL: 'auth/rejected-credential',\n  SECOND_FACTOR_ALREADY_ENROLLED: 'auth/second-factor-already-in-use',\n  SECOND_FACTOR_LIMIT_EXCEEDED: 'auth/maximum-second-factor-count-exceeded',\n  TENANT_ID_MISMATCH: 'auth/tenant-id-mismatch',\n  TIMEOUT: 'auth/timeout',\n  TOKEN_EXPIRED: 'auth/user-token-expired',\n  TOO_MANY_ATTEMPTS_TRY_LATER: 'auth/too-many-requests',\n  UNAUTHORIZED_DOMAIN: 'auth/unauthorized-continue-uri',\n  UNSUPPORTED_FIRST_FACTOR: 'auth/unsupported-first-factor',\n  UNSUPPORTED_PERSISTENCE: 'auth/unsupported-persistence-type',\n  UNSUPPORTED_TENANT_OPERATION: 'auth/unsupported-tenant-operation',\n  UNVERIFIED_EMAIL: 'auth/unverified-email',\n  USER_CANCELLED: 'auth/user-cancelled',\n  USER_DELETED: 'auth/user-not-found',\n  USER_DISABLED: 'auth/user-disabled',\n  USER_MISMATCH: 'auth/user-mismatch',\n  USER_SIGNED_OUT: 'auth/user-signed-out',\n  WEAK_PASSWORD: 'auth/weak-password',\n  WEB_STORAGE_UNSUPPORTED: 'auth/web-storage-unsupported',\n  ALREADY_INITIALIZED: 'auth/already-initialized',\n  RECAPTCHA_NOT_ENABLED: 'auth/recaptcha-not-enabled',\n  MISSING_RECAPTCHA_TOKEN: 'auth/missing-recaptcha-token',\n  INVALID_RECAPTCHA_TOKEN: 'auth/invalid-recaptcha-token',\n  INVALID_RECAPTCHA_ACTION: 'auth/invalid-recaptcha-action',\n  MISSING_CLIENT_TYPE: 'auth/missing-client-type',\n  MISSING_RECAPTCHA_VERSION: 'auth/missing-recaptcha-version',\n  INVALID_RECAPTCHA_VERSION: 'auth/invalid-recaptcha-version',\n  INVALID_REQ_TYPE: 'auth/invalid-req-type',\n  INVALID_HOSTING_LINK_DOMAIN: 'auth/invalid-hosting-link-domain'\n} as const;\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger, LogLevel } from '@firebase/logger';\nimport { SDK_VERSION } from '@firebase/app';\n\nexport { LogLevel };\n\nconst logClient = new Logger('@firebase/auth');\n\n// Helper methods are needed because variables can't be exported as read/write\nexport function _getLogLevel(): LogLevel {\n  return logClient.logLevel;\n}\n\nexport function _setLogLevel(newLevel: LogLevel): void {\n  logClient.logLevel = newLevel;\n}\n\nexport function _logDebug(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.DEBUG) {\n    logClient.debug(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n\nexport function _logWarn(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.WARN) {\n    logClient.warn(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n\nexport function _logError(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.ERROR) {\n    logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth } from '../../model/public_types';\nimport { ErrorFactory, FirebaseError } from '@firebase/util';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  _DEFAULT_AUTH_ERROR_FACTORY,\n  AuthErrorCode,\n  AuthErrorParams,\n  prodErrorMap,\n  ErrorMapRetriever\n} from '../errors';\nimport { _logError } from './log';\n\ntype AuthErrorListParams<K> = K extends keyof AuthErrorParams\n  ? [AuthErrorParams[K]]\n  : [];\ntype LessAppName<K extends AuthErrorCode> = Omit<AuthErrorParams[K], 'appName'>;\n\n/**\n * Unconditionally fails, throwing a developer facing INTERNAL_ERROR\n *\n * @example\n * ```javascript\n * fail(auth, AuthErrorCode.MFA_REQUIRED);  // Error: the MFA_REQUIRED error needs more params than appName\n * fail(auth, AuthErrorCode.MFA_REQUIRED, {serverResponse});  // Compiles\n * fail(AuthErrorCode.INTERNAL_ERROR);  // Compiles; internal error does not need appName\n * fail(AuthErrorCode.USER_DELETED);  // Error: USER_DELETED requires app name\n * fail(auth, AuthErrorCode.USER_DELETED);  // Compiles; USER_DELETED _only_ needs app name\n * ```\n *\n * @param appName App name for tagging the error\n * @throws FirebaseError\n */\nexport function _fail<K extends AuthErrorCode>(\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): never;\nexport function _fail<K extends AuthErrorCode>(\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): never;\nexport function _fail<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): never {\n  throw createErrorInternal(authOrCode, ...rest);\n}\n\nexport function _createError<K extends AuthErrorCode>(\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): FirebaseError;\nexport function _createError<K extends AuthErrorCode>(\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): FirebaseError;\nexport function _createError<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): FirebaseError {\n  return createErrorInternal(authOrCode, ...rest);\n}\n\nexport function _errorWithCustomMessage(\n  auth: Auth,\n  code: AuthErrorCode,\n  message: string\n): FirebaseError {\n  const errorMap = {\n    ...(prodErrorMap as ErrorMapRetriever)(),\n    [code]: message\n  };\n  const factory = new ErrorFactory<AuthErrorCode, AuthErrorParams>(\n    'auth',\n    'Firebase',\n    errorMap\n  );\n  return factory.create(code, {\n    appName: auth.name\n  });\n}\n\nexport function _serverAppCurrentUserOperationNotSupportedError(\n  auth: Auth\n): FirebaseError {\n  return _errorWithCustomMessage(\n    auth,\n    AuthErrorCode.OPERATION_NOT_SUPPORTED,\n    'Operations that alter the current user are not supported in conjunction with FirebaseServerApp'\n  );\n}\n\nexport function _assertInstanceOf(\n  auth: Auth,\n  object: object,\n  instance: unknown\n): void {\n  const constructorInstance = instance as { new (...args: unknown[]): unknown };\n  if (!(object instanceof constructorInstance)) {\n    if (constructorInstance.name !== object.constructor.name) {\n      _fail(auth, AuthErrorCode.ARGUMENT_ERROR);\n    }\n\n    throw _errorWithCustomMessage(\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR,\n      `Type of ${object.constructor.name} does not match expected instance.` +\n        `Did you pass a reference from a different Auth SDK?`\n    );\n  }\n}\n\nfunction createErrorInternal<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): FirebaseError {\n  if (typeof authOrCode !== 'string') {\n    const code = rest[0] as K;\n    const fullParams = [...rest.slice(1)] as AuthErrorListParams<K>;\n    if (fullParams[0]) {\n      fullParams[0].appName = authOrCode.name;\n    }\n\n    return (authOrCode as AuthInternal)._errorFactory.create(\n      code,\n      ...fullParams\n    );\n  }\n\n  return _DEFAULT_AUTH_ERROR_FACTORY.create(\n    authOrCode,\n    ...(rest as AuthErrorListParams<K>)\n  );\n}\n\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): asserts assertion;\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): asserts assertion;\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): asserts assertion {\n  if (!assertion) {\n    throw createErrorInternal(authOrCode, ...rest);\n  }\n}\n\n// We really do want to accept literally any function type here\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype TypeExpectation = Function | string | MapType;\n\ninterface MapType extends Record<string, TypeExpectation | Optional> {}\n\nclass Optional {\n  constructor(readonly type: TypeExpectation) {}\n}\n\nexport function opt(type: TypeExpectation): Optional {\n  return new Optional(type);\n}\n\n/**\n * Asserts the runtime types of arguments. The 'expected' field can be one of\n * a class, a string (representing a \"typeof\" call), or a record map of name\n * to type. Furthermore, the opt() function can be used to mark a field as\n * optional. For example:\n *\n * function foo(auth: Auth, profile: {displayName?: string}, update = false) {\n *   assertTypes(arguments, [AuthImpl, {displayName: opt('string')}, opt('boolean')]);\n * }\n *\n * opt() can be used for any type:\n * function foo(auth?: Auth) {\n *   assertTypes(arguments, [opt(AuthImpl)]);\n * }\n *\n * The string types can be or'd together, and you can use \"null\" as well (note\n * that typeof null === 'object'; this is an edge case). For example:\n *\n * function foo(profile: {displayName?: string | null}) {\n *   assertTypes(arguments, [{displayName: opt('string|null')}]);\n * }\n *\n * @param args\n * @param expected\n */\nexport function assertTypes(\n  args: Omit<IArguments, 'callee'>,\n  ...expected: Array<TypeExpectation | Optional>\n): void {\n  if (args.length > expected.length) {\n    _fail(AuthErrorCode.ARGUMENT_ERROR, {});\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    let expect = expected[i];\n    const arg = args[i];\n\n    if (expect instanceof Optional) {\n      // If the arg is undefined, then it matches \"optional\" and we can move to\n      // the next arg\n      if (typeof arg === 'undefined') {\n        continue;\n      }\n      expect = expect.type;\n    }\n\n    if (typeof expect === 'string') {\n      // Handle the edge case for null because typeof null === 'object'\n      if (expect.includes('null') && arg === null) {\n        continue;\n      }\n\n      const required = expect.split('|');\n      _assert(required.includes(typeof arg), AuthErrorCode.ARGUMENT_ERROR, {});\n    } else if (typeof expect === 'object') {\n      // Recursively check record arguments\n      const record = arg as Record<string, unknown>;\n      const map = expect as MapType;\n      const keys = Object.keys(expect);\n\n      assertTypes(\n        keys.map(k => record[k]),\n        ...keys.map(k => map[k])\n      );\n    } else {\n      _assert(arg instanceof expect, AuthErrorCode.ARGUMENT_ERROR, {});\n    }\n  }\n}\n\n/**\n * Unconditionally fails, throwing an internal error with the given message.\n *\n * @param failure type of failure encountered\n * @throws Error\n */\nexport function debugFail(failure: string): never {\n  // Log the failure in addition to throw an exception, just in case the\n  // exception is swallowed.\n  const message = `INTERNAL ASSERTION FAILED: ` + failure;\n  _logError(message);\n\n  // NOTE: We don't use FirebaseError here because these are internal failures\n  // that cannot be handled by the user. (Also it would create a circular\n  // dependency between the error and assert modules which doesn't work.)\n  throw new Error(message);\n}\n\n/**\n * Fails if the given assertion condition is false, throwing an Error with the\n * given message if it did.\n *\n * @param assertion\n * @param message\n */\nexport function debugAssert(\n  assertion: unknown,\n  message: string\n): asserts assertion {\n  if (!assertion) {\n    debugFail(message);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function _getCurrentUrl(): string {\n  return (typeof self !== 'undefined' && self.location?.href) || '';\n}\n\nexport function _isHttpOrHttps(): boolean {\n  return _getCurrentScheme() === 'http:' || _getCurrentScheme() === 'https:';\n}\n\nexport function _getCurrentScheme(): string | null {\n  return (typeof self !== 'undefined' && self.location?.protocol) || null;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isBrowserExtension } from '@firebase/util';\nimport { _isHttpOrHttps } from './location';\n\n/**\n * Determine whether the browser is working online\n */\nexport function _isOnline(): boolean {\n  if (\n    typeof navigator !== 'undefined' &&\n    navigator &&\n    'onLine' in navigator &&\n    typeof navigator.onLine === 'boolean' &&\n    // Apply only for traditional web apps and Chrome extensions.\n    // This is especially true for Cordova apps which have unreliable\n    // navigator.onLine behavior unless cordova-plugin-network-information is\n    // installed which overwrites the native navigator.onLine value and\n    // defines navigator.connection.\n    (_isHttpOrHttps() || isBrowserExtension() || 'connection' in navigator)\n  ) {\n    return navigator.onLine;\n  }\n  // If we can't determine the state, assume it is online.\n  return true;\n}\n\nexport function _getUserLanguage(): string | null {\n  if (typeof navigator === 'undefined') {\n    return null;\n  }\n  const navigatorLanguage: NavigatorLanguage = navigator;\n  return (\n    // Most reliable, but only supported in Chrome/Firefox.\n    (navigatorLanguage.languages && navigatorLanguage.languages[0]) ||\n    // Supported in most browsers, but returns the language of the browser\n    // UI, not the language set in browser settings.\n    navigatorLanguage.language ||\n    // Couldn't determine language.\n    null\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isMobileCordova, isReactNative } from '@firebase/util';\nimport { _isOnline } from './navigator';\nimport { debugAssert } from './assert';\n\nexport const enum DelayMin {\n  OFFLINE = 5000\n}\n\n/**\n * A structure to help pick between a range of long and short delay durations\n * depending on the current environment. In general, the long delay is used for\n * mobile environments whereas short delays are used for desktop environments.\n */\nexport class Delay {\n  // The default value for the offline delay timeout in ms.\n\n  private readonly isMobile: boolean;\n  constructor(\n    private readonly shortDelay: number,\n    private readonly longDelay: number\n  ) {\n    // Internal error when improperly initialized.\n    debugAssert(\n      longDelay > shortDelay,\n      'Short delay should be less than long delay!'\n    );\n    this.isMobile = isMobileCordova() || isReactNative();\n  }\n\n  get(): number {\n    if (!_isOnline()) {\n      // Pick the shorter timeout.\n      return Math.min(DelayMin.OFFLINE, this.shortDelay);\n    }\n    // If running in a mobile environment, return the long delay, otherwise\n    // return the short delay.\n    // This could be improved in the future to dynamically change based on other\n    // variables instead of just reading the current environment.\n    return this.isMobile ? this.longDelay : this.shortDelay;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ConfigInternal } from '../../model/auth';\nimport { debugAssert } from './assert';\n\nexport function _emulatorUrl(config: ConfigInternal, path?: string): string {\n  debugAssert(config.emulator, 'Emulator should always be set here');\n  const { url } = config.emulator;\n\n  if (!path) {\n    return url;\n  }\n\n  return `${url}${path.startsWith('/') ? path.slice(1) : path}`;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debugFail } from './assert';\n\nexport class FetchProvider {\n  private static fetchImpl: typeof fetch | null;\n  private static headersImpl: typeof Headers | null;\n  private static responseImpl: typeof Response | null;\n\n  static initialize(\n    fetchImpl: typeof fetch,\n    headersImpl?: typeof Headers,\n    responseImpl?: typeof Response\n  ): void {\n    this.fetchImpl = fetchImpl;\n    if (headersImpl) {\n      this.headersImpl = headersImpl;\n    }\n    if (responseImpl) {\n      this.responseImpl = responseImpl;\n    }\n  }\n\n  static fetch(): typeof fetch {\n    if (this.fetchImpl) {\n      return this.fetchImpl;\n    }\n    if (typeof self !== 'undefined' && 'fetch' in self) {\n      return self.fetch;\n    }\n    if (typeof globalThis !== 'undefined' && globalThis.fetch) {\n      return globalThis.fetch;\n    }\n    if (typeof fetch !== 'undefined') {\n      return fetch;\n    }\n    debugFail(\n      'Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n\n  static headers(): typeof Headers {\n    if (this.headersImpl) {\n      return this.headersImpl;\n    }\n    if (typeof self !== 'undefined' && 'Headers' in self) {\n      return self.Headers;\n    }\n    if (typeof globalThis !== 'undefined' && globalThis.Headers) {\n      return globalThis.Headers;\n    }\n    if (typeof Headers !== 'undefined') {\n      return Headers;\n    }\n    debugFail(\n      'Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n\n  static response(): typeof Response {\n    if (this.responseImpl) {\n      return this.responseImpl;\n    }\n    if (typeof self !== 'undefined' && 'Response' in self) {\n      return self.Response;\n    }\n    if (typeof globalThis !== 'undefined' && globalThis.Response) {\n      return globalThis.Response;\n    }\n    if (typeof Response !== 'undefined') {\n      return Response;\n    }\n    debugFail(\n      'Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../core/errors';\n\n/**\n * Errors that can be returned by the backend\n */\nexport const enum ServerError {\n  ADMIN_ONLY_OPERATION = 'ADMIN_ONLY_OPERATION',\n  BLOCKING_FUNCTION_ERROR_RESPONSE = 'BLOCKING_FUNCTION_ERROR_RESPONSE',\n  CAPTCHA_CHECK_FAILED = 'CAPTCHA_CHECK_FAILED',\n  CORS_UNSUPPORTED = 'CORS_UNSUPPORTED',\n  CREDENTIAL_MISMATCH = 'CREDENTIAL_MISMATCH',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN = 'CREDENTIAL_TOO_OLD_LOGIN_AGAIN',\n  DYNAMIC_LINK_NOT_ACTIVATED = 'DYNAMIC_LINK_NOT_ACTIVATED',\n  EMAIL_CHANGE_NEEDS_VERIFICATION = 'EMAIL_CHANGE_NEEDS_VERIFICATION',\n  EMAIL_EXISTS = 'EMAIL_EXISTS',\n  EMAIL_NOT_FOUND = 'EMAIL_NOT_FOUND',\n  EXPIRED_OOB_CODE = 'EXPIRED_OOB_CODE',\n  FEDERATED_USER_ID_ALREADY_LINKED = 'FEDERATED_USER_ID_ALREADY_LINKED',\n  INVALID_APP_CREDENTIAL = 'INVALID_APP_CREDENTIAL',\n  INVALID_APP_ID = 'INVALID_APP_ID',\n  INVALID_CERT_HASH = 'INVALID_CERT_HASH',\n  INVALID_CODE = 'INVALID_CODE',\n  INVALID_CONTINUE_URI = 'INVALID_CONTINUE_URI',\n  INVALID_CUSTOM_TOKEN = 'INVALID_CUSTOM_TOKEN',\n  INVALID_DYNAMIC_LINK_DOMAIN = 'INVALID_DYNAMIC_LINK_DOMAIN',\n  INVALID_EMAIL = 'INVALID_EMAIL',\n  INVALID_ID_TOKEN = 'INVALID_ID_TOKEN',\n  INVALID_IDP_RESPONSE = 'INVALID_IDP_RESPONSE',\n  INVALID_IDENTIFIER = 'INVALID_IDENTIFIER',\n  INVALID_LOGIN_CREDENTIALS = 'INVALID_LOGIN_CREDENTIALS',\n  INVALID_MESSAGE_PAYLOAD = 'INVALID_MESSAGE_PAYLOAD',\n  INVALID_MFA_PENDING_CREDENTIAL = 'INVALID_MFA_PENDING_CREDENTIAL',\n  INVALID_OAUTH_CLIENT_ID = 'INVALID_OAUTH_CLIENT_ID',\n  INVALID_OOB_CODE = 'INVALID_OOB_CODE',\n  INVALID_PASSWORD = 'INVALID_PASSWORD',\n  INVALID_PENDING_TOKEN = 'INVALID_PENDING_TOKEN',\n  INVALID_PHONE_NUMBER = 'INVALID_PHONE_NUMBER',\n  INVALID_PROVIDER_ID = 'INVALID_PROVIDER_ID',\n  INVALID_RECIPIENT_EMAIL = 'INVALID_RECIPIENT_EMAIL',\n  INVALID_SENDER = 'INVALID_SENDER',\n  INVALID_SESSION_INFO = 'INVALID_SESSION_INFO',\n  INVALID_TEMPORARY_PROOF = 'INVALID_TEMPORARY_PROOF',\n  INVALID_TENANT_ID = 'INVALID_TENANT_ID',\n  MFA_ENROLLMENT_NOT_FOUND = 'MFA_ENROLLMENT_NOT_FOUND',\n  MISSING_ANDROID_PACKAGE_NAME = 'MISSING_ANDROID_PACKAGE_NAME',\n  MISSING_APP_CREDENTIAL = 'MISSING_APP_CREDENTIAL',\n  MISSING_CODE = 'MISSING_CODE',\n  MISSING_CONTINUE_URI = 'MISSING_CONTINUE_URI',\n  MISSING_CUSTOM_TOKEN = 'MISSING_CUSTOM_TOKEN',\n  MISSING_IOS_BUNDLE_ID = 'MISSING_IOS_BUNDLE_ID',\n  MISSING_MFA_ENROLLMENT_ID = 'MISSING_MFA_ENROLLMENT_ID',\n  MISSING_MFA_PENDING_CREDENTIAL = 'MISSING_MFA_PENDING_CREDENTIAL',\n  MISSING_OOB_CODE = 'MISSING_OOB_CODE',\n  MISSING_OR_INVALID_NONCE = 'MISSING_OR_INVALID_NONCE',\n  MISSING_PASSWORD = 'MISSING_PASSWORD',\n  MISSING_REQ_TYPE = 'MISSING_REQ_TYPE',\n  MISSING_PHONE_NUMBER = 'MISSING_PHONE_NUMBER',\n  MISSING_SESSION_INFO = 'MISSING_SESSION_INFO',\n  OPERATION_NOT_ALLOWED = 'OPERATION_NOT_ALLOWED',\n  PASSWORD_LOGIN_DISABLED = 'PASSWORD_LOGIN_DISABLED',\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RESET_PASSWORD_EXCEED_LIMIT = 'RESET_PASSWORD_EXCEED_LIMIT',\n  REJECTED_CREDENTIAL = 'REJECTED_CREDENTIAL',\n  SECOND_FACTOR_EXISTS = 'SECOND_FACTOR_EXISTS',\n  SECOND_FACTOR_LIMIT_EXCEEDED = 'SECOND_FACTOR_LIMIT_EXCEEDED',\n  SESSION_EXPIRED = 'SESSION_EXPIRED',\n  TENANT_ID_MISMATCH = 'TENANT_ID_MISMATCH',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOO_MANY_ATTEMPTS_TRY_LATER = 'TOO_MANY_ATTEMPTS_TRY_LATER',\n  UNSUPPORTED_FIRST_FACTOR = 'UNSUPPORTED_FIRST_FACTOR',\n  UNSUPPORTED_TENANT_OPERATION = 'UNSUPPORTED_TENANT_OPERATION',\n  UNAUTHORIZED_DOMAIN = 'UNAUTHORIZED_DOMAIN',\n  UNVERIFIED_EMAIL = 'UNVERIFIED_EMAIL',\n  USER_CANCELLED = 'USER_CANCELLED',\n  USER_DISABLED = 'USER_DISABLED',\n  USER_NOT_FOUND = 'USER_NOT_FOUND',\n  WEAK_PASSWORD = 'WEAK_PASSWORD',\n  RECAPTCHA_NOT_ENABLED = 'RECAPTCHA_NOT_ENABLED',\n  MISSING_RECAPTCHA_TOKEN = 'MISSING_RECAPTCHA_TOKEN',\n  INVALID_RECAPTCHA_TOKEN = 'INVALID_RECAPTCHA_TOKEN',\n  INVALID_RECAPTCHA_ACTION = 'INVALID_RECAPTCHA_ACTION',\n  MISSING_CLIENT_TYPE = 'MISSING_CLIENT_TYPE',\n  MISSING_RECAPTCHA_VERSION = 'MISSING_RECAPTCHA_VERSION',\n  INVALID_RECAPTCHA_VERSION = 'INVALID_RECAPTCHA_VERSION',\n  INVALID_REQ_TYPE = 'INVALID_REQ_TYPE',\n  PASSWORD_DOES_NOT_MEET_REQUIREMENTS = 'PASSWORD_DOES_NOT_MEET_REQUIREMENTS',\n  INVALID_HOSTING_LINK_DOMAIN = 'INVALID_HOSTING_LINK_DOMAIN'\n}\n\n/**\n * API Response in the event of an error\n */\nexport interface JsonError {\n  error: {\n    code: number;\n    message: string;\n    errors?: [\n      {\n        message: ServerError;\n        domain: string;\n        reason: string;\n      }\n    ];\n  };\n}\n\n/**\n * Type definition for a map from server errors to developer visible errors\n */\nexport declare type ServerErrorMap<ApiError extends string> = {\n  readonly [K in ApiError]: AuthErrorCode;\n};\n\n/**\n * Map from errors returned by the server to errors to developer visible errors\n */\nexport const SERVER_ERROR_MAP: Partial<ServerErrorMap<ServerError>> = {\n  // Custom token errors.\n  [ServerError.CREDENTIAL_MISMATCH]: AuthErrorCode.CREDENTIAL_MISMATCH,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_CUSTOM_TOKEN]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Create Auth URI errors.\n  [ServerError.INVALID_IDENTIFIER]: AuthErrorCode.INVALID_EMAIL,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_CONTINUE_URI]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Sign in with email and password errors (some apply to sign up too).\n  [ServerError.INVALID_PASSWORD]: AuthErrorCode.INVALID_PASSWORD,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_PASSWORD]: AuthErrorCode.MISSING_PASSWORD,\n  // Thrown if Email Enumeration Protection is enabled in the project and the email or password is\n  // invalid.\n  [ServerError.INVALID_LOGIN_CREDENTIALS]: AuthErrorCode.INVALID_CREDENTIAL,\n\n  // Sign up with email and password errors.\n  [ServerError.EMAIL_EXISTS]: AuthErrorCode.EMAIL_EXISTS,\n  [ServerError.PASSWORD_LOGIN_DISABLED]: AuthErrorCode.OPERATION_NOT_ALLOWED,\n\n  // Verify assertion for sign in with credential errors:\n  [ServerError.INVALID_IDP_RESPONSE]: AuthErrorCode.INVALID_CREDENTIAL,\n  [ServerError.INVALID_PENDING_TOKEN]: AuthErrorCode.INVALID_CREDENTIAL,\n  [ServerError.FEDERATED_USER_ID_ALREADY_LINKED]:\n    AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,\n\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_REQ_TYPE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Send Password reset email errors:\n  [ServerError.EMAIL_NOT_FOUND]: AuthErrorCode.USER_DELETED,\n  [ServerError.RESET_PASSWORD_EXCEED_LIMIT]:\n    AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER,\n\n  [ServerError.EXPIRED_OOB_CODE]: AuthErrorCode.EXPIRED_OOB_CODE,\n  [ServerError.INVALID_OOB_CODE]: AuthErrorCode.INVALID_OOB_CODE,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_OOB_CODE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Operations that require ID token in request:\n  [ServerError.CREDENTIAL_TOO_OLD_LOGIN_AGAIN]:\n    AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN,\n  [ServerError.INVALID_ID_TOKEN]: AuthErrorCode.INVALID_AUTH,\n  [ServerError.TOKEN_EXPIRED]: AuthErrorCode.TOKEN_EXPIRED,\n  [ServerError.USER_NOT_FOUND]: AuthErrorCode.TOKEN_EXPIRED,\n\n  // Other errors.\n  [ServerError.TOO_MANY_ATTEMPTS_TRY_LATER]:\n    AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER,\n  [ServerError.PASSWORD_DOES_NOT_MEET_REQUIREMENTS]:\n    AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS,\n\n  // Phone Auth related errors.\n  [ServerError.INVALID_CODE]: AuthErrorCode.INVALID_CODE,\n  [ServerError.INVALID_SESSION_INFO]: AuthErrorCode.INVALID_SESSION_INFO,\n  [ServerError.INVALID_TEMPORARY_PROOF]: AuthErrorCode.INVALID_CREDENTIAL,\n  [ServerError.MISSING_SESSION_INFO]: AuthErrorCode.MISSING_SESSION_INFO,\n  [ServerError.SESSION_EXPIRED]: AuthErrorCode.CODE_EXPIRED,\n\n  // Other action code errors when additional settings passed.\n  // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.\n  // This is OK as this error will be caught by client side validation.\n  [ServerError.MISSING_ANDROID_PACKAGE_NAME]:\n    AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME,\n  [ServerError.UNAUTHORIZED_DOMAIN]: AuthErrorCode.UNAUTHORIZED_DOMAIN,\n\n  // getProjectConfig errors when clientId is passed.\n  [ServerError.INVALID_OAUTH_CLIENT_ID]: AuthErrorCode.INVALID_OAUTH_CLIENT_ID,\n\n  // User actions (sign-up or deletion) disabled errors.\n  [ServerError.ADMIN_ONLY_OPERATION]: AuthErrorCode.ADMIN_ONLY_OPERATION,\n\n  // Multi factor related errors.\n  [ServerError.INVALID_MFA_PENDING_CREDENTIAL]:\n    AuthErrorCode.INVALID_MFA_SESSION,\n  [ServerError.MFA_ENROLLMENT_NOT_FOUND]: AuthErrorCode.MFA_INFO_NOT_FOUND,\n  [ServerError.MISSING_MFA_ENROLLMENT_ID]: AuthErrorCode.MISSING_MFA_INFO,\n  [ServerError.MISSING_MFA_PENDING_CREDENTIAL]:\n    AuthErrorCode.MISSING_MFA_SESSION,\n  [ServerError.SECOND_FACTOR_EXISTS]:\n    AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED,\n  [ServerError.SECOND_FACTOR_LIMIT_EXCEEDED]:\n    AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED,\n\n  // Blocking functions related errors.\n  [ServerError.BLOCKING_FUNCTION_ERROR_RESPONSE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Recaptcha related errors.\n  [ServerError.RECAPTCHA_NOT_ENABLED]: AuthErrorCode.RECAPTCHA_NOT_ENABLED,\n  [ServerError.MISSING_RECAPTCHA_TOKEN]: AuthErrorCode.MISSING_RECAPTCHA_TOKEN,\n  [ServerError.INVALID_RECAPTCHA_TOKEN]: AuthErrorCode.INVALID_RECAPTCHA_TOKEN,\n  [ServerError.INVALID_RECAPTCHA_ACTION]:\n    AuthErrorCode.INVALID_RECAPTCHA_ACTION,\n  [ServerError.MISSING_CLIENT_TYPE]: AuthErrorCode.MISSING_CLIENT_TYPE,\n  [ServerError.MISSING_RECAPTCHA_VERSION]:\n    AuthErrorCode.MISSING_RECAPTCHA_VERSION,\n  [ServerError.INVALID_RECAPTCHA_VERSION]:\n    AuthErrorCode.INVALID_RECAPTCHA_VERSION,\n  [ServerError.INVALID_REQ_TYPE]: AuthErrorCode.INVALID_REQ_TYPE\n};\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseError,\n  isCloudflareWorker,\n  isCloudWorkstation,\n  querystring\n} from '@firebase/util';\n\nimport { AuthErrorCode, NamedErrorParams } from '../core/errors';\nimport {\n  _createError,\n  _errorWithCustomMessage,\n  _fail\n} from '../core/util/assert';\nimport { Delay } from '../core/util/delay';\nimport { _emulatorUrl } from '../core/util/emulator';\nimport { FetchProvider } from '../core/util/fetch_provider';\nimport { Auth } from '../model/public_types';\nimport { AuthInternal, ConfigInternal } from '../model/auth';\nimport { IdTokenResponse, TaggedWithTokenResponse } from '../model/id_token';\nimport { IdTokenMfaResponse } from './authentication/mfa';\nimport { SERVER_ERROR_MAP, ServerError, ServerErrorMap } from './errors';\nimport { PersistenceType } from '../core/persistence';\nimport { CookiePersistence } from '../platform_browser/persistence/cookie_storage';\n\nexport const enum HttpMethod {\n  POST = 'POST',\n  GET = 'GET'\n}\n\nexport const enum HttpHeader {\n  CONTENT_TYPE = 'Content-Type',\n  X_FIREBASE_LOCALE = 'X-Firebase-Locale',\n  X_CLIENT_VERSION = 'X-Client-Version',\n  X_FIREBASE_GMPID = 'X-Firebase-gmpid',\n  X_FIREBASE_CLIENT = 'X-Firebase-Client',\n  X_FIREBASE_APP_CHECK = 'X-Firebase-AppCheck'\n}\n\nexport const enum Endpoint {\n  CREATE_AUTH_URI = '/v1/accounts:createAuthUri',\n  DELETE_ACCOUNT = '/v1/accounts:delete',\n  RESET_PASSWORD = '/v1/accounts:resetPassword',\n  SIGN_UP = '/v1/accounts:signUp',\n  SIGN_IN_WITH_CUSTOM_TOKEN = '/v1/accounts:signInWithCustomToken',\n  SIGN_IN_WITH_EMAIL_LINK = '/v1/accounts:signInWithEmailLink',\n  SIGN_IN_WITH_IDP = '/v1/accounts:signInWithIdp',\n  SIGN_IN_WITH_PASSWORD = '/v1/accounts:signInWithPassword',\n  SIGN_IN_WITH_PHONE_NUMBER = '/v1/accounts:signInWithPhoneNumber',\n  SEND_VERIFICATION_CODE = '/v1/accounts:sendVerificationCode',\n  SEND_OOB_CODE = '/v1/accounts:sendOobCode',\n  SET_ACCOUNT_INFO = '/v1/accounts:update',\n  GET_ACCOUNT_INFO = '/v1/accounts:lookup',\n  GET_RECAPTCHA_PARAM = '/v1/recaptchaParams',\n  START_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:start',\n  FINALIZE_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:finalize',\n  START_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:start',\n  FINALIZE_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:finalize',\n  WITHDRAW_MFA = '/v2/accounts/mfaEnrollment:withdraw',\n  GET_PROJECT_CONFIG = '/v1/projects',\n  GET_RECAPTCHA_CONFIG = '/v2/recaptchaConfig',\n  GET_PASSWORD_POLICY = '/v2/passwordPolicy',\n  TOKEN = '/v1/token',\n  REVOKE_TOKEN = '/v2/accounts:revokeToken'\n}\n\nconst CookieAuthProxiedEndpoints: string[] = [\n  Endpoint.SIGN_IN_WITH_CUSTOM_TOKEN,\n  Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n  Endpoint.SIGN_IN_WITH_IDP,\n  Endpoint.SIGN_IN_WITH_PASSWORD,\n  Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n  Endpoint.TOKEN\n];\n\nexport const enum RecaptchaClientType {\n  WEB = 'CLIENT_TYPE_WEB',\n  ANDROID = 'CLIENT_TYPE_ANDROID',\n  IOS = 'CLIENT_TYPE_IOS'\n}\n\nexport const enum RecaptchaVersion {\n  ENTERPRISE = 'RECAPTCHA_ENTERPRISE'\n}\n\nexport const enum RecaptchaActionName {\n  SIGN_IN_WITH_PASSWORD = 'signInWithPassword',\n  GET_OOB_CODE = 'getOobCode',\n  SIGN_UP_PASSWORD = 'signUpPassword',\n  SEND_VERIFICATION_CODE = 'sendVerificationCode',\n  MFA_SMS_ENROLLMENT = 'mfaSmsEnrollment',\n  MFA_SMS_SIGNIN = 'mfaSmsSignIn'\n}\n\nexport const enum EnforcementState {\n  ENFORCE = 'ENFORCE',\n  AUDIT = 'AUDIT',\n  OFF = 'OFF',\n  ENFORCEMENT_STATE_UNSPECIFIED = 'ENFORCEMENT_STATE_UNSPECIFIED'\n}\n\n// Providers that have reCAPTCHA Enterprise support.\nexport const enum RecaptchaAuthProvider {\n  EMAIL_PASSWORD_PROVIDER = 'EMAIL_PASSWORD_PROVIDER',\n  PHONE_PROVIDER = 'PHONE_PROVIDER'\n}\n\nexport const DEFAULT_API_TIMEOUT_MS = new Delay(30_000, 60_000);\n\nexport function _addTidIfNecessary<T extends { tenantId?: string }>(\n  auth: Auth,\n  request: T\n): T {\n  if (auth.tenantId && !request.tenantId) {\n    return {\n      ...request,\n      tenantId: auth.tenantId\n    };\n  }\n  return request;\n}\n\nexport async function _performApiRequest<T, V>(\n  auth: Auth,\n  method: HttpMethod,\n  path: Endpoint,\n  request?: T,\n  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}\n): Promise<V> {\n  return _performFetchWithErrorHandling(auth, customErrorMap, async () => {\n    let body = {};\n    let params = {};\n    if (request) {\n      if (method === HttpMethod.GET) {\n        params = request;\n      } else {\n        body = {\n          body: JSON.stringify(request)\n        };\n      }\n    }\n\n    const query = querystring({\n      key: auth.config.apiKey,\n      ...params\n    }).slice(1);\n\n    const headers = await (auth as AuthInternal)._getAdditionalHeaders();\n    headers[HttpHeader.CONTENT_TYPE] = 'application/json';\n\n    if (auth.languageCode) {\n      headers[HttpHeader.X_FIREBASE_LOCALE] = auth.languageCode;\n    }\n\n    const fetchArgs: RequestInit = {\n      method,\n      headers,\n      ...body\n    };\n\n    /* Security-conscious server-side frameworks tend to have built in mitigations for referrer\n       problems\". See the Cloudflare GitHub issue #487: Error: The 'referrerPolicy' field on\n       'RequestInitializerDict' is not implemented.\"\n       https://github.com/cloudflare/next-on-pages/issues/487 */\n    if (!isCloudflareWorker()) {\n      fetchArgs.referrerPolicy = 'no-referrer';\n    }\n\n    if (auth.emulatorConfig && isCloudWorkstation(auth.emulatorConfig.host)) {\n      fetchArgs.credentials = 'include';\n    }\n\n    return FetchProvider.fetch()(\n      await _getFinalTarget(auth, auth.config.apiHost, path, query),\n      fetchArgs\n    );\n  });\n}\n\nexport async function _performFetchWithErrorHandling<V>(\n  auth: Auth,\n  customErrorMap: Partial<ServerErrorMap<ServerError>>,\n  fetchFn: () => Promise<Response>\n): Promise<V> {\n  (auth as AuthInternal)._canInitEmulator = false;\n  const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };\n  try {\n    const networkTimeout = new NetworkTimeout<Response>(auth);\n    const response: Response = await Promise.race<Promise<Response>>([\n      fetchFn(),\n      networkTimeout.promise\n    ]);\n\n    // If we've reached this point, the fetch succeeded and the networkTimeout\n    // didn't throw; clear the network timeout delay so that Node won't hang\n    networkTimeout.clearNetworkTimeout();\n\n    const json = await response.json();\n    if ('needConfirmation' in json) {\n      throw _makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, json);\n    }\n\n    if (response.ok && !('errorMessage' in json)) {\n      return json;\n    } else {\n      const errorMessage = response.ok ? json.errorMessage : json.error.message;\n      const [serverErrorCode, serverErrorMessage] = errorMessage.split(' : ');\n      if (serverErrorCode === ServerError.FEDERATED_USER_ID_ALREADY_LINKED) {\n        throw _makeTaggedError(\n          auth,\n          AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,\n          json\n        );\n      } else if (serverErrorCode === ServerError.EMAIL_EXISTS) {\n        throw _makeTaggedError(auth, AuthErrorCode.EMAIL_EXISTS, json);\n      } else if (serverErrorCode === ServerError.USER_DISABLED) {\n        throw _makeTaggedError(auth, AuthErrorCode.USER_DISABLED, json);\n      }\n      const authError =\n        errorMap[serverErrorCode as ServerError] ||\n        (serverErrorCode\n          .toLowerCase()\n          .replace(/[_\\s]+/g, '-') as unknown as AuthErrorCode);\n      if (serverErrorMessage) {\n        throw _errorWithCustomMessage(auth, authError, serverErrorMessage);\n      } else {\n        _fail(auth, authError);\n      }\n    }\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      throw e;\n    }\n    // Changing this to a different error code will log user out when there is a network error\n    // because we treat any error other than NETWORK_REQUEST_FAILED as token is invalid.\n    // https://github.com/firebase/firebase-js-sdk/blob/4fbc73610d70be4e0852e7de63a39cb7897e8546/packages/auth/src/core/auth/auth_impl.ts#L309-L316\n    _fail(auth, AuthErrorCode.NETWORK_REQUEST_FAILED, { 'message': String(e) });\n  }\n}\n\nexport async function _performSignInRequest<T, V extends IdTokenResponse>(\n  auth: Auth,\n  method: HttpMethod,\n  path: Endpoint,\n  request?: T,\n  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}\n): Promise<V> {\n  const serverResponse = await _performApiRequest<T, V | IdTokenMfaResponse>(\n    auth,\n    method,\n    path,\n    request,\n    customErrorMap\n  );\n  if ('mfaPendingCredential' in serverResponse) {\n    _fail(auth, AuthErrorCode.MFA_REQUIRED, {\n      _serverResponse: serverResponse\n    });\n  }\n\n  return serverResponse as V;\n}\n\nexport async function _getFinalTarget(\n  auth: Auth,\n  host: string,\n  path: string,\n  query: string\n): Promise<string> {\n  const base = `${host}${path}?${query}`;\n\n  const authInternal = auth as AuthInternal;\n  const finalTarget = authInternal.config.emulator\n    ? _emulatorUrl(auth.config as ConfigInternal, base)\n    : `${auth.config.apiScheme}://${base}`;\n\n  // Cookie auth works by MiTMing the signIn and token endpoints from the developer's backend,\n  // saving the idToken and refreshToken into cookies, and then redacting the refreshToken\n  // from the response\n  if (CookieAuthProxiedEndpoints.includes(path)) {\n    // Persistence manager is async, we need to await it. We can't just wait for auth initialized\n    // here since auth initialization calls this function.\n    await authInternal._persistenceManagerAvailable;\n    if (authInternal._getPersistenceType() === PersistenceType.COOKIE) {\n      const cookiePersistence =\n        authInternal._getPersistence() as CookiePersistence;\n      return cookiePersistence._getFinalTarget(finalTarget).toString();\n    }\n  }\n\n  return finalTarget;\n}\n\nexport function _parseEnforcementState(\n  enforcementStateStr: string\n): EnforcementState {\n  switch (enforcementStateStr) {\n    case 'ENFORCE':\n      return EnforcementState.ENFORCE;\n    case 'AUDIT':\n      return EnforcementState.AUDIT;\n    case 'OFF':\n      return EnforcementState.OFF;\n    default:\n      return EnforcementState.ENFORCEMENT_STATE_UNSPECIFIED;\n  }\n}\n\nclass NetworkTimeout<T> {\n  // Node timers and browser timers are fundamentally incompatible, but we\n  // don't care about the value here\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private timer: any | null = null;\n  readonly promise = new Promise<T>((_, reject) => {\n    this.timer = setTimeout(() => {\n      return reject(\n        _createError(this.auth, AuthErrorCode.NETWORK_REQUEST_FAILED)\n      );\n    }, DEFAULT_API_TIMEOUT_MS.get());\n  });\n\n  clearNetworkTimeout(): void {\n    clearTimeout(this.timer);\n  }\n\n  constructor(private readonly auth: Auth) {}\n}\n\ninterface PotentialResponse extends IdTokenResponse {\n  email?: string;\n  phoneNumber?: string;\n}\n\nexport function _makeTaggedError(\n  auth: Auth,\n  code: AuthErrorCode,\n  response: PotentialResponse\n): FirebaseError {\n  const errorParams: NamedErrorParams = {\n    appName: auth.name\n  };\n\n  if (response.email) {\n    errorParams.email = response.email;\n  }\n  if (response.phoneNumber) {\n    errorParams.phoneNumber = response.phoneNumber;\n  }\n\n  const error = _createError(auth, code, errorParams);\n\n  // We know customData is defined on error because errorParams is defined\n  (error.customData! as TaggedWithTokenResponse)._tokenResponse = response;\n  return error;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { RecaptchaParameters } from '../../model/public_types';\nimport {\n  GetRecaptchaConfigResponse,\n  RecaptchaEnforcementProviderState\n} from '../../api/authentication/recaptcha';\nimport {\n  EnforcementState,\n  RecaptchaAuthProvider,\n  _parseEnforcementState\n} from '../../api/index';\n\n// reCAPTCHA v2 interface\nexport interface Recaptcha {\n  render: (container: HTMLElement, parameters: RecaptchaParameters) => number;\n  getResponse: (id: number) => string;\n  execute: (id: number) => unknown;\n  reset: (id: number) => unknown;\n}\n\nexport function isV2(\n  grecaptcha: Recaptcha | GreCAPTCHA | undefined\n): grecaptcha is Recaptcha {\n  return (\n    grecaptcha !== undefined &&\n    (grecaptcha as Recaptcha).getResponse !== undefined\n  );\n}\n\n// reCAPTCHA Enterprise & v3 shared interface\nexport interface GreCAPTCHATopLevel extends GreCAPTCHA {\n  enterprise: GreCAPTCHA;\n}\n\n// reCAPTCHA Enterprise interface\nexport interface GreCAPTCHA {\n  ready: (callback: () => void) => void;\n  execute: (siteKey: string, options: { action: string }) => Promise<string>;\n  render: (\n    container: string | HTMLElement,\n    parameters: GreCAPTCHARenderOption\n  ) => string;\n}\n\nexport interface GreCAPTCHARenderOption {\n  sitekey: string;\n  size: 'invisible';\n}\n\nexport function isEnterprise(\n  grecaptcha: Recaptcha | GreCAPTCHA | undefined\n): grecaptcha is GreCAPTCHATopLevel {\n  return (\n    grecaptcha !== undefined &&\n    (grecaptcha as GreCAPTCHATopLevel).enterprise !== undefined\n  );\n}\n\n// TODO(chuanr): Replace this with the AuthWindow after resolving the dependency issue in Node.js env.\ndeclare global {\n  interface Window {\n    grecaptcha?: Recaptcha | GreCAPTCHATopLevel;\n  }\n}\n\nexport class RecaptchaConfig {\n  /**\n   * The reCAPTCHA site key.\n   */\n  siteKey: string = '';\n\n  /**\n   * The list of providers and their enablement status for reCAPTCHA Enterprise.\n   */\n  recaptchaEnforcementState: RecaptchaEnforcementProviderState[] = [];\n\n  constructor(response: GetRecaptchaConfigResponse) {\n    if (response.recaptchaKey === undefined) {\n      throw new Error('recaptchaKey undefined');\n    }\n    // Example response.recaptchaKey: \"projects/proj123/keys/sitekey123\"\n    this.siteKey = response.recaptchaKey.split('/')[3];\n    this.recaptchaEnforcementState = response.recaptchaEnforcementState;\n  }\n\n  /**\n   * Returns the reCAPTCHA Enterprise enforcement state for the given provider.\n   *\n   * @param providerStr - The provider whose enforcement state is to be returned.\n   * @returns The reCAPTCHA Enterprise enforcement state for the given provider.\n   */\n  getProviderEnforcementState(providerStr: string): EnforcementState | null {\n    if (\n      !this.recaptchaEnforcementState ||\n      this.recaptchaEnforcementState.length === 0\n    ) {\n      return null;\n    }\n\n    for (const recaptchaEnforcementState of this.recaptchaEnforcementState) {\n      if (\n        recaptchaEnforcementState.provider &&\n        recaptchaEnforcementState.provider === providerStr\n      ) {\n        return _parseEnforcementState(\n          recaptchaEnforcementState.enforcementState\n        );\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Returns true if the reCAPTCHA Enterprise enforcement state for the provider is set to ENFORCE or AUDIT.\n   *\n   * @param providerStr - The provider whose enablement state is to be returned.\n   * @returns Whether or not reCAPTCHA Enterprise protection is enabled for the given provider.\n   */\n  isProviderEnabled(providerStr: string): boolean {\n    return (\n      this.getProviderEnforcementState(providerStr) ===\n        EnforcementState.ENFORCE ||\n      this.getProviderEnforcementState(providerStr) === EnforcementState.AUDIT\n    );\n  }\n\n  /**\n   * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise\n   * returns false.\n   *\n   * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.\n   */\n  isAnyProviderEnabled(): boolean {\n    return (\n      this.isProviderEnabled(RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER) ||\n      this.isProviderEnabled(RecaptchaAuthProvider.PHONE_PROVIDER)\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _performApiRequest,\n  _addTidIfNecessary\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\ninterface GetRecaptchaParamResponse {\n  recaptchaSiteKey?: string;\n}\n\nexport async function getRecaptchaParams(auth: Auth): Promise<string> {\n  return (\n    (\n      await _performApiRequest<void, GetRecaptchaParamResponse>(\n        auth,\n        HttpMethod.GET,\n        Endpoint.GET_RECAPTCHA_PARAM\n      )\n    ).recaptchaSiteKey || ''\n  );\n}\n\n// The following functions are for reCAPTCHA enterprise integration.\ninterface GetRecaptchaConfigRequest {\n  tenantId?: string;\n  clientType?: RecaptchaClientType;\n  version?: RecaptchaVersion;\n}\n\nexport interface RecaptchaEnforcementProviderState {\n  provider: string;\n  enforcementState: string;\n}\n\nexport interface GetRecaptchaConfigResponse {\n  recaptchaKey: string;\n  recaptchaEnforcementState: RecaptchaEnforcementProviderState[];\n}\n\nexport async function getRecaptchaConfig(\n  auth: Auth,\n  request: GetRecaptchaConfigRequest\n): Promise<GetRecaptchaConfigResponse> {\n  return _performApiRequest<\n    GetRecaptchaConfigRequest,\n    GetRecaptchaConfigResponse\n  >(\n    auth,\n    HttpMethod.GET,\n    Endpoint.GET_RECAPTCHA_CONFIG,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { MfaEnrollment } from './mfa';\nimport { Auth } from '../../model/public_types';\n\nexport interface DeleteAccountRequest {\n  idToken: string;\n}\n\nexport async function deleteAccount(\n  auth: Auth,\n  request: DeleteAccountRequest\n): Promise<void> {\n  return _performApiRequest<DeleteAccountRequest, void>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.DELETE_ACCOUNT,\n    request\n  );\n}\n\nexport interface ProviderUserInfo {\n  providerId: string;\n  rawId?: string;\n  email?: string;\n  displayName?: string;\n  photoUrl?: string;\n  phoneNumber?: string;\n}\n\nexport interface DeleteLinkedAccountsRequest {\n  idToken: string;\n  deleteProvider: string[];\n}\n\nexport interface DeleteLinkedAccountsResponse {\n  providerUserInfo: ProviderUserInfo[];\n}\n\nexport async function deleteLinkedAccounts(\n  auth: Auth,\n  request: DeleteLinkedAccountsRequest\n): Promise<DeleteLinkedAccountsResponse> {\n  return _performApiRequest<\n    DeleteLinkedAccountsRequest,\n    DeleteLinkedAccountsResponse\n  >(auth, HttpMethod.POST, Endpoint.SET_ACCOUNT_INFO, request);\n}\n\nexport interface APIUserInfo {\n  localId?: string;\n  displayName?: string;\n  photoUrl?: string;\n  email?: string;\n  emailVerified?: boolean;\n  phoneNumber?: string;\n  lastLoginAt?: number;\n  createdAt?: number;\n  tenantId?: string;\n  passwordHash?: string;\n  providerUserInfo?: ProviderUserInfo[];\n  mfaInfo?: MfaEnrollment[];\n}\n\nexport interface GetAccountInfoRequest {\n  idToken: string;\n}\n\nexport interface GetAccountInfoResponse {\n  users: APIUserInfo[];\n}\n\nexport async function getAccountInfo(\n  auth: Auth,\n  request: GetAccountInfoRequest\n): Promise<GetAccountInfoResponse> {\n  return _performApiRequest<GetAccountInfoRequest, GetAccountInfoResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.GET_ACCOUNT_INFO,\n    request\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function utcTimestampToDateString(\n  utcTimestamp?: string | number\n): string | undefined {\n  if (!utcTimestamp) {\n    return undefined;\n  }\n  try {\n    // Convert to date object.\n    const date = new Date(Number(utcTimestamp));\n    // Test date is valid.\n    if (!isNaN(date.getTime())) {\n      // Convert to UTC date string.\n      return date.toUTCString();\n    }\n  } catch (e) {\n    // Do nothing. undefined will be returned.\n  }\n  return undefined;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IdTokenResult, ParsedToken, User } from '../../model/public_types';\nimport { base64Decode, getModularInstance } from '@firebase/util';\n\nimport { UserInternal } from '../../model/user';\nimport { _assert } from '../util/assert';\nimport { _logError } from '../util/log';\nimport { utcTimestampToDateString } from '../util/time';\nimport { AuthErrorCode } from '../errors';\n\n/**\n * Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.\n *\n * @remarks\n * Returns the current token if it has not expired or if it will not expire in the next five\n * minutes. Otherwise, this will refresh the token and return a new one.\n *\n * @param user - The user.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport function getIdToken(user: User, forceRefresh = false): Promise<string> {\n  return getModularInstance(user).getIdToken(forceRefresh);\n}\n\n/**\n * Returns a deserialized JSON Web Token (JWT) used to identify the user to a Firebase service.\n *\n * @remarks\n * Returns the current token if it has not expired or if it will not expire in the next five\n * minutes. Otherwise, this will refresh the token and return a new one.\n *\n * @param user - The user.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport async function getIdTokenResult(\n  user: User,\n  forceRefresh = false\n): Promise<IdTokenResult> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const token = await userInternal.getIdToken(forceRefresh);\n  const claims = _parseToken(token);\n\n  _assert(\n    claims && claims.exp && claims.auth_time && claims.iat,\n    userInternal.auth,\n    AuthErrorCode.INTERNAL_ERROR\n  );\n  const firebase =\n    typeof claims.firebase === 'object' ? claims.firebase : undefined;\n\n  const signInProvider: string | undefined = firebase?.['sign_in_provider'];\n\n  return {\n    claims,\n    token,\n    authTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.auth_time)\n    )!,\n    issuedAtTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.iat)\n    )!,\n    expirationTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.exp)\n    )!,\n    signInProvider: signInProvider || null,\n    signInSecondFactor: firebase?.['sign_in_second_factor'] || null\n  };\n}\n\nfunction secondsStringToMilliseconds(seconds: string): number {\n  return Number(seconds) * 1000;\n}\n\nexport function _parseToken(token: string): ParsedToken | null {\n  const [algorithm, payload, signature] = token.split('.');\n  if (\n    algorithm === undefined ||\n    payload === undefined ||\n    signature === undefined\n  ) {\n    _logError('JWT malformed, contained fewer than 3 sections');\n    return null;\n  }\n\n  try {\n    const decoded = base64Decode(payload);\n    if (!decoded) {\n      _logError('Failed to decode base64 JWT payload');\n      return null;\n    }\n    return JSON.parse(decoded);\n  } catch (e) {\n    _logError(\n      'Caught error parsing JWT payload as JSON',\n      (e as Error)?.toString()\n    );\n    return null;\n  }\n}\n\n/**\n * Extract expiresIn TTL from a token by subtracting the expiration from the issuance.\n */\nexport function _tokenExpiresIn(token: string): number {\n  const parsedToken = _parseToken(token);\n  _assert(parsedToken, AuthErrorCode.INTERNAL_ERROR);\n  _assert(typeof parsedToken.exp !== 'undefined', AuthErrorCode.INTERNAL_ERROR);\n  _assert(typeof parsedToken.iat !== 'undefined', AuthErrorCode.INTERNAL_ERROR);\n  return Number(parsedToken.exp) - Number(parsedToken.iat);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\n\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\n\nexport async function _logoutIfInvalidated<T>(\n  user: UserInternal,\n  promise: Promise<T>,\n  bypassAuthState = false\n): Promise<T> {\n  if (bypassAuthState) {\n    return promise;\n  }\n  try {\n    return await promise;\n  } catch (e) {\n    if (e instanceof FirebaseError && isUserInvalidated(e)) {\n      if (user.auth.currentUser === user) {\n        await user.auth.signOut();\n      }\n    }\n\n    throw e;\n  }\n}\n\nfunction isUserInvalidated({ code }: FirebaseError): boolean {\n  return (\n    code === `auth/${AuthErrorCode.USER_DISABLED}` ||\n    code === `auth/${AuthErrorCode.TOKEN_EXPIRED}`\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\n\n// Refresh the token five minutes before expiration\nexport const enum Duration {\n  OFFSET = 5 * 1000 * 60,\n  RETRY_BACKOFF_MIN = 30 * 1000,\n  RETRY_BACKOFF_MAX = 16 * 60 * 1000\n}\n\nexport class ProactiveRefresh {\n  private isRunning = false;\n\n  // Node timers and browser timers return fundamentally different types.\n  // We don't actually care what the value is but TS won't accept unknown and\n  // we can't cast properly in both environments.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private timerId: any | null = null;\n  private errorBackoff = Duration.RETRY_BACKOFF_MIN;\n\n  constructor(private readonly user: UserInternal) {}\n\n  _start(): void {\n    if (this.isRunning) {\n      return;\n    }\n\n    this.isRunning = true;\n    this.schedule();\n  }\n\n  _stop(): void {\n    if (!this.isRunning) {\n      return;\n    }\n\n    this.isRunning = false;\n    if (this.timerId !== null) {\n      clearTimeout(this.timerId);\n    }\n  }\n\n  private getInterval(wasError: boolean): number {\n    if (wasError) {\n      const interval = this.errorBackoff;\n      this.errorBackoff = Math.min(\n        this.errorBackoff * 2,\n        Duration.RETRY_BACKOFF_MAX\n      );\n      return interval;\n    } else {\n      // Reset the error backoff\n      this.errorBackoff = Duration.RETRY_BACKOFF_MIN;\n      const expTime = this.user.stsTokenManager.expirationTime ?? 0;\n      const interval = expTime - Date.now() - Duration.OFFSET;\n\n      return Math.max(0, interval);\n    }\n  }\n\n  private schedule(wasError = false): void {\n    if (!this.isRunning) {\n      // Just in case...\n      return;\n    }\n\n    const interval = this.getInterval(wasError);\n    this.timerId = setTimeout(async () => {\n      await this.iteration();\n    }, interval);\n  }\n\n  private async iteration(): Promise<void> {\n    try {\n      await this.user.getIdToken(true);\n    } catch (e) {\n      // Only retry on network errors\n      if (\n        (e as FirebaseError)?.code ===\n        `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`\n      ) {\n        this.schedule(/* wasError */ true);\n      }\n\n      return;\n    }\n    this.schedule();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserMetadata as UserMetadataType } from '../../model/public_types';\n\nimport { utcTimestampToDateString } from '../util/time';\n\nexport class UserMetadata implements UserMetadataType {\n  creationTime?: string;\n  lastSignInTime?: string;\n\n  constructor(\n    private createdAt?: string | number,\n    private lastLoginAt?: string | number\n  ) {\n    this._initializeTime();\n  }\n\n  private _initializeTime(): void {\n    this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);\n    this.creationTime = utcTimestampToDateString(this.createdAt);\n  }\n\n  _copy(metadata: UserMetadata): void {\n    this.createdAt = metadata.createdAt;\n    this.lastLoginAt = metadata.lastLoginAt;\n    this._initializeTime();\n  }\n\n  toJSON(): object {\n    return {\n      createdAt: this.createdAt,\n      lastLoginAt: this.lastLoginAt\n    };\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User, UserInfo } from '../../model/public_types';\n\nimport {\n  getAccountInfo,\n  ProviderUserInfo\n} from '../../api/account_management/account';\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { UserMetadata } from './user_metadata';\nimport { getModularInstance } from '@firebase/util';\n\nexport async function _reloadWithoutSaving(user: UserInternal): Promise<void> {\n  const auth = user.auth;\n  const idToken = await user.getIdToken();\n  const response = await _logoutIfInvalidated(\n    user,\n    getAccountInfo(auth, { idToken })\n  );\n\n  _assert(response?.users.length, auth, AuthErrorCode.INTERNAL_ERROR);\n\n  const coreAccount = response.users[0];\n\n  user._notifyReloadListener(coreAccount);\n\n  const newProviderData = coreAccount.providerUserInfo?.length\n    ? extractProviderData(coreAccount.providerUserInfo)\n    : [];\n\n  const providerData = mergeProviderData(user.providerData, newProviderData);\n\n  // Preserves the non-nonymous status of the stored user, even if no more\n  // credentials (federated or email/password) are linked to the user. If\n  // the user was previously anonymous, then use provider data to update.\n  // On the other hand, if it was not anonymous before, it should never be\n  // considered anonymous now.\n  const oldIsAnonymous = user.isAnonymous;\n  const newIsAnonymous =\n    !(user.email && coreAccount.passwordHash) && !providerData?.length;\n  const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;\n\n  const updates: Partial<UserInternal> = {\n    uid: coreAccount.localId,\n    displayName: coreAccount.displayName || null,\n    photoURL: coreAccount.photoUrl || null,\n    email: coreAccount.email || null,\n    emailVerified: coreAccount.emailVerified || false,\n    phoneNumber: coreAccount.phoneNumber || null,\n    tenantId: coreAccount.tenantId || null,\n    providerData,\n    metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),\n    isAnonymous\n  };\n\n  Object.assign(user, updates);\n}\n\n/**\n * Reloads user account data, if signed in.\n *\n * @param user - The user.\n *\n * @public\n */\nexport async function reload(user: User): Promise<void> {\n  const userInternal: UserInternal = getModularInstance(user) as UserInternal;\n  await _reloadWithoutSaving(userInternal);\n\n  // Even though the current user hasn't changed, update\n  // current user will trigger a persistence update w/ the\n  // new info.\n  await userInternal.auth._persistUserIfCurrent(userInternal);\n  userInternal.auth._notifyListenersIfCurrent(userInternal);\n}\n\nfunction mergeProviderData(\n  original: UserInfo[],\n  newData: UserInfo[]\n): UserInfo[] {\n  const deduped = original.filter(\n    o => !newData.some(n => n.providerId === o.providerId)\n  );\n  return [...deduped, ...newData];\n}\n\nexport function extractProviderData(providers: ProviderUserInfo[]): UserInfo[] {\n  return providers.map(({ providerId, ...provider }) => {\n    return {\n      providerId,\n      uid: provider.rawId || '',\n      displayName: provider.displayName || null,\n      email: provider.email || null,\n      phoneNumber: provider.phoneNumber || null,\n      photoURL: provider.photoUrl || null\n    };\n  });\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable camelcase */\n\nimport { isCloudWorkstation, querystring } from '@firebase/util';\n\nimport {\n  _getFinalTarget,\n  _performFetchWithErrorHandling,\n  _performApiRequest,\n  _addTidIfNecessary,\n  HttpMethod,\n  HttpHeader,\n  Endpoint\n} from '../index';\nimport { FetchProvider } from '../../core/util/fetch_provider';\nimport { Auth } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\n\nexport const enum TokenType {\n  REFRESH_TOKEN = 'REFRESH_TOKEN',\n  ACCESS_TOKEN = 'ACCESS_TOKEN'\n}\n\n/** The server responses with snake_case; we convert to camelCase */\ninterface RequestStsTokenServerResponse {\n  access_token: string;\n  expires_in: string;\n  refresh_token: string;\n}\n\nexport interface RequestStsTokenResponse {\n  accessToken: string;\n  expiresIn: string;\n  refreshToken: string;\n}\n\nexport interface RevokeTokenRequest {\n  providerId: string;\n  tokenType: TokenType;\n  token: string;\n  idToken: string;\n  tenantId?: string;\n}\n\nexport interface RevokeTokenResponse {}\n\nexport async function requestStsToken(\n  auth: Auth,\n  refreshToken: string\n): Promise<RequestStsTokenResponse> {\n  const response =\n    await _performFetchWithErrorHandling<RequestStsTokenServerResponse>(\n      auth,\n      {},\n      async () => {\n        const body = querystring({\n          'grant_type': 'refresh_token',\n          'refresh_token': refreshToken\n        }).slice(1);\n        const { tokenApiHost, apiKey } = auth.config;\n        const url = await _getFinalTarget(\n          auth,\n          tokenApiHost,\n          Endpoint.TOKEN,\n          `key=${apiKey}`\n        );\n\n        const headers = await (auth as AuthInternal)._getAdditionalHeaders();\n        headers[HttpHeader.CONTENT_TYPE] = 'application/x-www-form-urlencoded';\n\n        const options: RequestInit = {\n          method: HttpMethod.POST,\n          headers,\n          body\n        };\n        if (\n          auth.emulatorConfig &&\n          isCloudWorkstation(auth.emulatorConfig.host)\n        ) {\n          options.credentials = 'include';\n        }\n        return FetchProvider.fetch()(url, options);\n      }\n    );\n\n  // The response comes back in snake_case. Convert to camel:\n  return {\n    accessToken: response.access_token,\n    expiresIn: response.expires_in,\n    refreshToken: response.refresh_token\n  };\n}\n\nexport async function revokeToken(\n  auth: Auth,\n  request: RevokeTokenRequest\n): Promise<RevokeTokenResponse> {\n  return _performApiRequest<RevokeTokenRequest, RevokeTokenResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.REVOKE_TOKEN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FinalizeMfaResponse } from '../../api/authentication/mfa';\nimport { requestStsToken } from '../../api/authentication/token';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { PersistedBlob } from '../persistence';\nimport { _assert, debugFail } from '../util/assert';\nimport { _tokenExpiresIn } from './id_token_result';\n\n/**\n * The number of milliseconds before the official expiration time of a token\n * to refresh that token, to provide a buffer for RPCs to complete.\n */\nexport const enum Buffer {\n  TOKEN_REFRESH = 30_000\n}\n\n/**\n * We need to mark this class as internal explicitly to exclude it in the public typings, because\n * it references AuthInternal which has a circular dependency with UserInternal.\n *\n * @internal\n */\nexport class StsTokenManager {\n  refreshToken: string | null = null;\n  accessToken: string | null = null;\n  expirationTime: number | null = null;\n\n  get isExpired(): boolean {\n    return (\n      !this.expirationTime ||\n      Date.now() > this.expirationTime - Buffer.TOKEN_REFRESH\n    );\n  }\n\n  updateFromServerResponse(\n    response: IdTokenResponse | FinalizeMfaResponse\n  ): void {\n    _assert(response.idToken, AuthErrorCode.INTERNAL_ERROR);\n    _assert(\n      typeof response.idToken !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    _assert(\n      typeof response.refreshToken !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const expiresIn =\n      'expiresIn' in response && typeof response.expiresIn !== 'undefined'\n        ? Number(response.expiresIn)\n        : _tokenExpiresIn(response.idToken);\n    this.updateTokensAndExpiration(\n      response.idToken,\n      response.refreshToken,\n      expiresIn\n    );\n  }\n\n  updateFromIdToken(idToken: string): void {\n    _assert(idToken.length !== 0, AuthErrorCode.INTERNAL_ERROR);\n    const expiresIn = _tokenExpiresIn(idToken);\n    this.updateTokensAndExpiration(idToken, null, expiresIn);\n  }\n\n  async getToken(\n    auth: AuthInternal,\n    forceRefresh = false\n  ): Promise<string | null> {\n    if (!forceRefresh && this.accessToken && !this.isExpired) {\n      return this.accessToken;\n    }\n\n    _assert(this.refreshToken, auth, AuthErrorCode.TOKEN_EXPIRED);\n\n    if (this.refreshToken) {\n      await this.refresh(auth, this.refreshToken!);\n      return this.accessToken;\n    }\n\n    return null;\n  }\n\n  clearRefreshToken(): void {\n    this.refreshToken = null;\n  }\n\n  private async refresh(auth: AuthInternal, oldToken: string): Promise<void> {\n    const { accessToken, refreshToken, expiresIn } = await requestStsToken(\n      auth,\n      oldToken\n    );\n    this.updateTokensAndExpiration(\n      accessToken,\n      refreshToken,\n      Number(expiresIn)\n    );\n  }\n\n  private updateTokensAndExpiration(\n    accessToken: string,\n    refreshToken: string | null,\n    expiresInSec: number\n  ): void {\n    this.refreshToken = refreshToken || null;\n    this.accessToken = accessToken || null;\n    this.expirationTime = Date.now() + expiresInSec * 1000;\n  }\n\n  static fromJSON(appName: string, object: PersistedBlob): StsTokenManager {\n    const { refreshToken, accessToken, expirationTime } = object;\n\n    const manager = new StsTokenManager();\n    if (refreshToken) {\n      _assert(typeof refreshToken === 'string', AuthErrorCode.INTERNAL_ERROR, {\n        appName\n      });\n      manager.refreshToken = refreshToken;\n    }\n    if (accessToken) {\n      _assert(typeof accessToken === 'string', AuthErrorCode.INTERNAL_ERROR, {\n        appName\n      });\n      manager.accessToken = accessToken;\n    }\n    if (expirationTime) {\n      _assert(\n        typeof expirationTime === 'number',\n        AuthErrorCode.INTERNAL_ERROR,\n        {\n          appName\n        }\n      );\n      manager.expirationTime = expirationTime;\n    }\n    return manager;\n  }\n\n  toJSON(): object {\n    return {\n      refreshToken: this.refreshToken,\n      accessToken: this.accessToken,\n      expirationTime: this.expirationTime\n    };\n  }\n\n  _assign(stsTokenManager: StsTokenManager): void {\n    this.accessToken = stsTokenManager.accessToken;\n    this.refreshToken = stsTokenManager.refreshToken;\n    this.expirationTime = stsTokenManager.expirationTime;\n  }\n\n  _clone(): StsTokenManager {\n    return Object.assign(new StsTokenManager(), this.toJSON());\n  }\n\n  _performRefresh(): never {\n    return debugFail('not implemented');\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IdTokenResult, UserInfo } from '../../model/public_types';\nimport { NextFn } from '@firebase/util';\nimport {\n  APIUserInfo,\n  GetAccountInfoResponse,\n  deleteAccount\n} from '../../api/account_management/account';\nimport { FinalizeMfaResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport {\n  MutableUserInfo,\n  UserInternal,\n  UserParameters\n} from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { PersistedBlob } from '../persistence';\nimport {\n  _assert,\n  _serverAppCurrentUserOperationNotSupportedError\n} from '../util/assert';\nimport { getIdTokenResult } from './id_token_result';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { ProactiveRefresh } from './proactive_refresh';\nimport { extractProviderData, _reloadWithoutSaving, reload } from './reload';\nimport { StsTokenManager } from './token_manager';\nimport { UserMetadata } from './user_metadata';\nimport { ProviderId } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\n\nfunction assertStringOrUndefined(\n  assertion: unknown,\n  appName: string\n): asserts assertion is string | undefined {\n  _assert(\n    typeof assertion === 'string' || typeof assertion === 'undefined',\n    AuthErrorCode.INTERNAL_ERROR,\n    { appName }\n  );\n}\n\nexport class UserImpl implements UserInternal {\n  // For the user object, provider is always Firebase.\n  readonly providerId = ProviderId.FIREBASE;\n  stsTokenManager: StsTokenManager;\n  // Last known accessToken so we know when it changes\n  private accessToken: string | null;\n\n  uid: string;\n  auth: AuthInternal;\n  emailVerified: boolean;\n  isAnonymous: boolean;\n  tenantId: string | null;\n  readonly metadata: UserMetadata;\n  providerData: MutableUserInfo[];\n\n  // Optional fields from UserInfo\n  displayName: string | null;\n  email: string | null;\n  phoneNumber: string | null;\n  photoURL: string | null;\n\n  _redirectEventId?: string;\n  private readonly proactiveRefresh = new ProactiveRefresh(this);\n\n  constructor({ uid, auth, stsTokenManager, ...opt }: UserParameters) {\n    this.uid = uid;\n    this.auth = auth;\n    this.stsTokenManager = stsTokenManager;\n    this.accessToken = stsTokenManager.accessToken;\n    this.displayName = opt.displayName || null;\n    this.email = opt.email || null;\n    this.emailVerified = opt.emailVerified || false;\n    this.phoneNumber = opt.phoneNumber || null;\n    this.photoURL = opt.photoURL || null;\n    this.isAnonymous = opt.isAnonymous || false;\n    this.tenantId = opt.tenantId || null;\n    this.providerData = opt.providerData ? [...opt.providerData] : [];\n    this.metadata = new UserMetadata(\n      opt.createdAt || undefined,\n      opt.lastLoginAt || undefined\n    );\n  }\n\n  async getIdToken(forceRefresh?: boolean): Promise<string> {\n    const accessToken = await _logoutIfInvalidated(\n      this,\n      this.stsTokenManager.getToken(this.auth, forceRefresh)\n    );\n    _assert(accessToken, this.auth, AuthErrorCode.INTERNAL_ERROR);\n\n    if (this.accessToken !== accessToken) {\n      this.accessToken = accessToken;\n      await this.auth._persistUserIfCurrent(this);\n      this.auth._notifyListenersIfCurrent(this);\n    }\n\n    return accessToken;\n  }\n\n  getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult> {\n    return getIdTokenResult(this, forceRefresh);\n  }\n\n  reload(): Promise<void> {\n    return reload(this);\n  }\n\n  private reloadUserInfo: APIUserInfo | null = null;\n  private reloadListener: NextFn<APIUserInfo> | null = null;\n\n  _assign(user: UserInternal): void {\n    if (this === user) {\n      return;\n    }\n    _assert(this.uid === user.uid, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.displayName = user.displayName;\n    this.photoURL = user.photoURL;\n    this.email = user.email;\n    this.emailVerified = user.emailVerified;\n    this.phoneNumber = user.phoneNumber;\n    this.isAnonymous = user.isAnonymous;\n    this.tenantId = user.tenantId;\n    this.providerData = user.providerData.map(userInfo => ({ ...userInfo }));\n    this.metadata._copy(user.metadata);\n    this.stsTokenManager._assign(user.stsTokenManager);\n  }\n\n  _clone(auth: AuthInternal): UserInternal {\n    const newUser = new UserImpl({\n      ...this,\n      auth,\n      stsTokenManager: this.stsTokenManager._clone()\n    });\n    newUser.metadata._copy(this.metadata);\n    return newUser;\n  }\n\n  _onReload(callback: NextFn<APIUserInfo>): void {\n    // There should only ever be one listener, and that is a single instance of MultiFactorUser\n    _assert(!this.reloadListener, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.reloadListener = callback;\n    if (this.reloadUserInfo) {\n      this._notifyReloadListener(this.reloadUserInfo);\n      this.reloadUserInfo = null;\n    }\n  }\n\n  _notifyReloadListener(userInfo: APIUserInfo): void {\n    if (this.reloadListener) {\n      this.reloadListener(userInfo);\n    } else {\n      // If no listener is subscribed yet, save the result so it's available when they do subscribe\n      this.reloadUserInfo = userInfo;\n    }\n  }\n\n  _startProactiveRefresh(): void {\n    this.proactiveRefresh._start();\n  }\n\n  _stopProactiveRefresh(): void {\n    this.proactiveRefresh._stop();\n  }\n\n  async _updateTokensIfNecessary(\n    response: IdTokenResponse | FinalizeMfaResponse,\n    reload = false\n  ): Promise<void> {\n    let tokensRefreshed = false;\n    if (\n      response.idToken &&\n      response.idToken !== this.stsTokenManager.accessToken\n    ) {\n      this.stsTokenManager.updateFromServerResponse(response);\n      tokensRefreshed = true;\n    }\n\n    if (reload) {\n      await _reloadWithoutSaving(this);\n    }\n\n    await this.auth._persistUserIfCurrent(this);\n    if (tokensRefreshed) {\n      this.auth._notifyListenersIfCurrent(this);\n    }\n  }\n\n  async delete(): Promise<void> {\n    if (_isFirebaseServerApp(this.auth.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this.auth)\n      );\n    }\n    const idToken = await this.getIdToken();\n    await _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken }));\n    this.stsTokenManager.clearRefreshToken();\n\n    // TODO: Determine if cancellable-promises are necessary to use in this class so that delete()\n    //       cancels pending actions...\n\n    return this.auth.signOut();\n  }\n\n  toJSON(): PersistedBlob {\n    return {\n      uid: this.uid,\n      email: this.email || undefined,\n      emailVerified: this.emailVerified,\n      displayName: this.displayName || undefined,\n      isAnonymous: this.isAnonymous,\n      photoURL: this.photoURL || undefined,\n      phoneNumber: this.phoneNumber || undefined,\n      tenantId: this.tenantId || undefined,\n      providerData: this.providerData.map(userInfo => ({ ...userInfo })),\n      stsTokenManager: this.stsTokenManager.toJSON(),\n      // Redirect event ID must be maintained in case there is a pending\n      // redirect event.\n      _redirectEventId: this._redirectEventId,\n      ...this.metadata.toJSON(),\n\n      // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):\n      apiKey: this.auth.config.apiKey,\n      appName: this.auth.name\n      // Missing authDomain will be tolerated by the legacy SDK.\n      // stsTokenManager.apiKey isn't actually required (despite the legacy SDK persisting it).\n    };\n  }\n\n  get refreshToken(): string {\n    return this.stsTokenManager.refreshToken || '';\n  }\n\n  static _fromJSON(auth: AuthInternal, object: PersistedBlob): UserInternal {\n    const displayName = object.displayName ?? undefined;\n    const email = object.email ?? undefined;\n    const phoneNumber = object.phoneNumber ?? undefined;\n    const photoURL = object.photoURL ?? undefined;\n    const tenantId = object.tenantId ?? undefined;\n    const _redirectEventId = object._redirectEventId ?? undefined;\n    const createdAt = object.createdAt ?? undefined;\n    const lastLoginAt = object.lastLoginAt ?? undefined;\n    const {\n      uid,\n      emailVerified,\n      isAnonymous,\n      providerData,\n      stsTokenManager: plainObjectTokenManager\n    } = object;\n\n    _assert(uid && plainObjectTokenManager, auth, AuthErrorCode.INTERNAL_ERROR);\n\n    const stsTokenManager = StsTokenManager.fromJSON(\n      this.name,\n      plainObjectTokenManager as PersistedBlob\n    );\n\n    _assert(typeof uid === 'string', auth, AuthErrorCode.INTERNAL_ERROR);\n    assertStringOrUndefined(displayName, auth.name);\n    assertStringOrUndefined(email, auth.name);\n    _assert(\n      typeof emailVerified === 'boolean',\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    _assert(\n      typeof isAnonymous === 'boolean',\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    assertStringOrUndefined(phoneNumber, auth.name);\n    assertStringOrUndefined(photoURL, auth.name);\n    assertStringOrUndefined(tenantId, auth.name);\n    assertStringOrUndefined(_redirectEventId, auth.name);\n    assertStringOrUndefined(createdAt, auth.name);\n    assertStringOrUndefined(lastLoginAt, auth.name);\n    const user = new UserImpl({\n      uid,\n      auth,\n      email,\n      emailVerified,\n      displayName,\n      isAnonymous,\n      photoURL,\n      phoneNumber,\n      tenantId,\n      stsTokenManager,\n      createdAt,\n      lastLoginAt\n    });\n\n    if (providerData && Array.isArray(providerData)) {\n      user.providerData = providerData.map(userInfo => ({ ...userInfo }));\n    }\n\n    if (_redirectEventId) {\n      user._redirectEventId = _redirectEventId;\n    }\n\n    return user;\n  }\n\n  /**\n   * Initialize a User from an idToken server response\n   * @param auth\n   * @param idTokenResponse\n   */\n  static async _fromIdTokenResponse(\n    auth: AuthInternal,\n    idTokenResponse: IdTokenResponse,\n    isAnonymous: boolean = false\n  ): Promise<UserInternal> {\n    const stsTokenManager = new StsTokenManager();\n    stsTokenManager.updateFromServerResponse(idTokenResponse);\n\n    // Initialize the Firebase Auth user.\n    const user = new UserImpl({\n      uid: idTokenResponse.localId,\n      auth,\n      stsTokenManager,\n      isAnonymous\n    });\n\n    // Updates the user info and data and resolves with a user instance.\n    await _reloadWithoutSaving(user);\n    return user;\n  }\n\n  /**\n   * Initialize a User from an idToken server response\n   * @param auth\n   * @param idTokenResponse\n   */\n  static async _fromGetAccountInfoResponse(\n    auth: AuthInternal,\n    response: GetAccountInfoResponse,\n    idToken: string\n  ): Promise<UserInternal> {\n    const coreAccount = response.users[0];\n    _assert(coreAccount.localId !== undefined, AuthErrorCode.INTERNAL_ERROR);\n\n    const providerData: UserInfo[] =\n      coreAccount.providerUserInfo !== undefined\n        ? extractProviderData(coreAccount.providerUserInfo)\n        : [];\n\n    const isAnonymous =\n      !(coreAccount.email && coreAccount.passwordHash) && !providerData?.length;\n\n    const stsTokenManager = new StsTokenManager();\n    stsTokenManager.updateFromIdToken(idToken);\n\n    // Initialize the Firebase Auth user.\n    const user = new UserImpl({\n      uid: coreAccount.localId,\n      auth,\n      stsTokenManager,\n      isAnonymous\n    });\n\n    // update the user with data from the GetAccountInfo response.\n    const updates: Partial<UserInternal> = {\n      uid: coreAccount.localId,\n      displayName: coreAccount.displayName || null,\n      photoURL: coreAccount.photoUrl || null,\n      email: coreAccount.email || null,\n      emailVerified: coreAccount.emailVerified || false,\n      phoneNumber: coreAccount.phoneNumber || null,\n      tenantId: coreAccount.tenantId || null,\n      providerData,\n      metadata: new UserMetadata(\n        coreAccount.createdAt,\n        coreAccount.lastLoginAt\n      ),\n      isAnonymous:\n        !(coreAccount.email && coreAccount.passwordHash) &&\n        !providerData?.length\n    };\n\n    Object.assign(user, updates);\n    return user;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debugAssert } from './assert';\n\n/**\n * Our API has a lot of one-off constants that are used to do things.\n * Unfortunately we can't export these as classes instantiated directly since\n * the constructor may side effect and therefore can't be proven to be safely\n * culled. Instead, we export these classes themselves as a lowerCamelCase\n * constant, and instantiate them under the hood.\n */\nexport interface SingletonInstantiator<T> {\n  new (): T;\n}\n\nconst instanceCache: Map<unknown, unknown> = new Map();\n\nexport function _getInstance<T>(cls: unknown): T {\n  debugAssert(cls instanceof Function, 'Expected a class definition');\n  let instance = instanceCache.get(cls) as T | undefined;\n\n  if (instance) {\n    debugAssert(\n      instance instanceof cls,\n      'Instance stored in cache mismatched with class'\n    );\n    return instance;\n  }\n\n  instance = new (cls as SingletonInstantiator<T>)();\n  instanceCache.set(cls, instance);\n  return instance;\n}\n\nexport function _clearInstanceMap(): void {\n  instanceCache.clear();\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Persistence } from '../../model/public_types';\n\nimport {\n  PersistenceInternal,\n  PersistenceType,\n  PersistenceValue,\n  StorageEventListener\n} from '../persistence';\n\nexport class InMemoryPersistence implements PersistenceInternal {\n  static type: 'NONE' = 'NONE';\n  readonly type = PersistenceType.NONE;\n  storage: Record<string, PersistenceValue> = {};\n\n  async _isAvailable(): Promise<boolean> {\n    return true;\n  }\n\n  async _set(key: string, value: PersistenceValue): Promise<void> {\n    this.storage[key] = value;\n  }\n\n  async _get<T extends PersistenceValue>(key: string): Promise<T | null> {\n    const value = this.storage[key];\n    return value === undefined ? null : (value as T);\n  }\n\n  async _remove(key: string): Promise<void> {\n    delete this.storage[key];\n  }\n\n  _addListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers\n    return;\n  }\n\n  _removeListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers\n    return;\n  }\n}\n\n/**\n * An implementation of {@link Persistence} of type 'NONE'.\n *\n * @public\n */\nexport const inMemoryPersistence: Persistence = InMemoryPersistence;\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getAccountInfo } from '../../api/account_management/account';\nimport { ApiKey, AppName, AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { PersistedBlob, PersistenceInternal } from '../persistence';\nimport { UserImpl } from '../user/user_impl';\nimport { _getInstance } from '../util/instantiator';\nimport { inMemoryPersistence } from './in_memory';\n\nexport const enum KeyName {\n  AUTH_USER = 'authUser',\n  AUTH_EVENT = 'authEvent',\n  REDIRECT_USER = 'redirectUser',\n  PERSISTENCE_USER = 'persistence'\n}\nexport const enum Namespace {\n  PERSISTENCE = 'firebase'\n}\n\nexport function _persistenceKeyName(\n  key: string,\n  apiKey: ApiKey,\n  appName: AppName\n): string {\n  return `${Namespace.PERSISTENCE}:${key}:${apiKey}:${appName}`;\n}\n\nexport class PersistenceUserManager {\n  private readonly fullUserKey: string;\n  private readonly fullPersistenceKey: string;\n  private readonly boundEventHandler: () => void;\n\n  private constructor(\n    public persistence: PersistenceInternal,\n    private readonly auth: AuthInternal,\n    private readonly userKey: string\n  ) {\n    const { config, name } = this.auth;\n    this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name);\n    this.fullPersistenceKey = _persistenceKeyName(\n      KeyName.PERSISTENCE_USER,\n      config.apiKey,\n      name\n    );\n    this.boundEventHandler = auth._onStorageEvent.bind(auth);\n    this.persistence._addListener(this.fullUserKey, this.boundEventHandler);\n  }\n\n  setCurrentUser(user: UserInternal): Promise<void> {\n    return this.persistence._set(this.fullUserKey, user.toJSON());\n  }\n\n  async getCurrentUser(): Promise<UserInternal | null> {\n    const blob = await this.persistence._get<PersistedBlob | string>(\n      this.fullUserKey\n    );\n    if (!blob) {\n      return null;\n    }\n    if (typeof blob === 'string') {\n      const response = await getAccountInfo(this.auth, { idToken: blob }).catch(\n        () => undefined\n      );\n      if (!response) {\n        return null;\n      }\n      return UserImpl._fromGetAccountInfoResponse(this.auth, response, blob);\n    }\n    return UserImpl._fromJSON(this.auth, blob);\n  }\n\n  removeCurrentUser(): Promise<void> {\n    return this.persistence._remove(this.fullUserKey);\n  }\n\n  savePersistenceForRedirect(): Promise<void> {\n    return this.persistence._set(\n      this.fullPersistenceKey,\n      this.persistence.type\n    );\n  }\n\n  async setPersistence(newPersistence: PersistenceInternal): Promise<void> {\n    if (this.persistence === newPersistence) {\n      return;\n    }\n\n    const currentUser = await this.getCurrentUser();\n    await this.removeCurrentUser();\n\n    this.persistence = newPersistence;\n\n    if (currentUser) {\n      return this.setCurrentUser(currentUser);\n    }\n  }\n\n  delete(): void {\n    this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);\n  }\n\n  static async create(\n    auth: AuthInternal,\n    persistenceHierarchy: PersistenceInternal[],\n    userKey = KeyName.AUTH_USER\n  ): Promise<PersistenceUserManager> {\n    if (!persistenceHierarchy.length) {\n      return new PersistenceUserManager(\n        _getInstance(inMemoryPersistence),\n        auth,\n        userKey\n      );\n    }\n\n    // Eliminate any persistences that are not available\n    const availablePersistences = (\n      await Promise.all(\n        persistenceHierarchy.map(async persistence => {\n          if (await persistence._isAvailable()) {\n            return persistence;\n          }\n          return undefined;\n        })\n      )\n    ).filter(persistence => persistence) as PersistenceInternal[];\n\n    // Fall back to the first persistence listed, or in memory if none available\n    let selectedPersistence =\n      availablePersistences[0] ||\n      _getInstance<PersistenceInternal>(inMemoryPersistence);\n\n    const key = _persistenceKeyName(userKey, auth.config.apiKey, auth.name);\n\n    // Pull out the existing user, setting the chosen persistence to that\n    // persistence if the user exists.\n    let userToMigrate: UserInternal | null = null;\n    // Note, here we check for a user in _all_ persistences, not just the\n    // ones deemed available. If we can migrate a user out of a broken\n    // persistence, we will (but only if that persistence supports migration).\n    for (const persistence of persistenceHierarchy) {\n      try {\n        const blob = await persistence._get<PersistedBlob | string>(key);\n        if (blob) {\n          let user: UserInternal;\n          if (typeof blob === 'string') {\n            const response = await getAccountInfo(auth, {\n              idToken: blob\n            }).catch(() => undefined);\n            if (!response) {\n              break;\n            }\n            user = await UserImpl._fromGetAccountInfoResponse(\n              auth,\n              response,\n              blob\n            );\n          } else {\n            user = UserImpl._fromJSON(auth, blob); // throws for unparsable blob (wrong format)\n          }\n          if (persistence !== selectedPersistence) {\n            userToMigrate = user;\n          }\n          selectedPersistence = persistence;\n          break;\n        }\n      } catch {}\n    }\n\n    // If we find the user in a persistence that does support migration, use\n    // that migration path (of only persistences that support migration)\n    const migrationHierarchy = availablePersistences.filter(\n      p => p._shouldAllowMigration\n    );\n\n    // If the persistence does _not_ allow migration, just finish off here\n    if (\n      !selectedPersistence._shouldAllowMigration ||\n      !migrationHierarchy.length\n    ) {\n      return new PersistenceUserManager(selectedPersistence, auth, userKey);\n    }\n\n    selectedPersistence = migrationHierarchy[0];\n    if (userToMigrate) {\n      // This normally shouldn't throw since chosenPersistence.isAvailable() is true, but if it does\n      // we'll just let it bubble to surface the error.\n      await selectedPersistence._set(key, userToMigrate.toJSON());\n    }\n\n    // Attempt to clear the key in other persistences but ignore errors. This helps prevent issues\n    // such as users getting stuck with a previous account after signing out and refreshing the tab.\n    await Promise.all(\n      persistenceHierarchy.map(async persistence => {\n        if (persistence !== selectedPersistence) {\n          try {\n            await persistence._remove(key);\n          } catch {}\n        }\n      })\n    );\n    return new PersistenceUserManager(selectedPersistence, auth, userKey);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isIE, getUA } from '@firebase/util';\n\ninterface NavigatorStandalone extends Navigator {\n  standalone?: unknown;\n}\n\ninterface Document {\n  documentMode?: number;\n}\n\n/**\n * Enums for Browser name.\n */\nexport const enum BrowserName {\n  ANDROID = 'Android',\n  BLACKBERRY = 'Blackberry',\n  EDGE = 'Edge',\n  FIREFOX = 'Firefox',\n  IE = 'IE',\n  IEMOBILE = 'IEMobile',\n  OPERA = 'Opera',\n  OTHER = 'Other',\n  CHROME = 'Chrome',\n  SAFARI = 'Safari',\n  SILK = 'Silk',\n  WEBOS = 'Webos'\n}\n\n/**\n * Determine the browser for the purposes of reporting usage to the API\n */\nexport function _getBrowserName(userAgent: string): BrowserName | string {\n  const ua = userAgent.toLowerCase();\n  if (ua.includes('opera/') || ua.includes('opr/') || ua.includes('opios/')) {\n    return BrowserName.OPERA;\n  } else if (_isIEMobile(ua)) {\n    // Windows phone IEMobile browser.\n    return BrowserName.IEMOBILE;\n  } else if (ua.includes('msie') || ua.includes('trident/')) {\n    return BrowserName.IE;\n  } else if (ua.includes('edge/')) {\n    return BrowserName.EDGE;\n  } else if (_isFirefox(ua)) {\n    return BrowserName.FIREFOX;\n  } else if (ua.includes('silk/')) {\n    return BrowserName.SILK;\n  } else if (_isBlackBerry(ua)) {\n    // Blackberry browser.\n    return BrowserName.BLACKBERRY;\n  } else if (_isWebOS(ua)) {\n    // WebOS default browser.\n    return BrowserName.WEBOS;\n  } else if (_isSafari(ua)) {\n    return BrowserName.SAFARI;\n  } else if (\n    (ua.includes('chrome/') || _isChromeIOS(ua)) &&\n    !ua.includes('edge/')\n  ) {\n    return BrowserName.CHROME;\n  } else if (_isAndroid(ua)) {\n    // Android stock browser.\n    return BrowserName.ANDROID;\n  } else {\n    // Most modern browsers have name/version at end of user agent string.\n    const re = /([a-zA-Z\\d\\.]+)\\/[a-zA-Z\\d\\.]*$/;\n    const matches = userAgent.match(re);\n    if (matches?.length === 2) {\n      return matches[1];\n    }\n  }\n  return BrowserName.OTHER;\n}\n\nexport function _isFirefox(ua = getUA()): boolean {\n  return /firefox\\//i.test(ua);\n}\n\nexport function _isSafari(userAgent = getUA()): boolean {\n  const ua = userAgent.toLowerCase();\n  return (\n    ua.includes('safari/') &&\n    !ua.includes('chrome/') &&\n    !ua.includes('crios/') &&\n    !ua.includes('android')\n  );\n}\n\nexport function _isChromeIOS(ua = getUA()): boolean {\n  return /crios\\//i.test(ua);\n}\n\nexport function _isIEMobile(ua = getUA()): boolean {\n  return /iemobile/i.test(ua);\n}\n\nexport function _isAndroid(ua = getUA()): boolean {\n  return /android/i.test(ua);\n}\n\nexport function _isBlackBerry(ua = getUA()): boolean {\n  return /blackberry/i.test(ua);\n}\n\nexport function _isWebOS(ua = getUA()): boolean {\n  return /webos/i.test(ua);\n}\n\nexport function _isIOS(ua = getUA()): boolean {\n  return (\n    /iphone|ipad|ipod/i.test(ua) ||\n    (/macintosh/i.test(ua) && /mobile/i.test(ua))\n  );\n}\n\nexport function _isIOS7Or8(ua = getUA()): boolean {\n  return (\n    /(iPad|iPhone|iPod).*OS 7_\\d/i.test(ua) ||\n    /(iPad|iPhone|iPod).*OS 8_\\d/i.test(ua)\n  );\n}\n\nexport function _isIOSStandalone(ua = getUA()): boolean {\n  return _isIOS(ua) && !!(window.navigator as NavigatorStandalone)?.standalone;\n}\n\nexport function _isIE10(): boolean {\n  return isIE() && (document as Document).documentMode === 10;\n}\n\nexport function _isMobileBrowser(ua: string = getUA()): boolean {\n  // TODO: implement getBrowserName equivalent for OS.\n  return (\n    _isIOS(ua) ||\n    _isAndroid(ua) ||\n    _isWebOS(ua) ||\n    _isBlackBerry(ua) ||\n    /windows phone/i.test(ua) ||\n    _isIEMobile(ua)\n  );\n}\n\nexport function _isIframe(): boolean {\n  try {\n    // Check that the current window is not the top window.\n    // If so, return true.\n    return !!(window && window !== window.top);\n  } catch (e) {\n    return false;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SDK_VERSION } from '@firebase/app';\nimport { _getBrowserName } from './browser';\nimport { getUA } from '@firebase/util';\n\nexport const enum ClientImplementation {\n  CORE = 'JsCore'\n}\n\n/**\n * @internal\n */\nexport const enum ClientPlatform {\n  BROWSER = 'Browser',\n  NODE = 'Node',\n  REACT_NATIVE = 'ReactNative',\n  CORDOVA = 'Cordova',\n  WORKER = 'Worker',\n  WEB_EXTENSION = 'WebExtension'\n}\n\n/*\n * Determine the SDK version string\n */\nexport function _getClientVersion(\n  clientPlatform: ClientPlatform,\n  frameworks: readonly string[] = []\n): string {\n  let reportedPlatform: string;\n  switch (clientPlatform) {\n    case ClientPlatform.BROWSER:\n      // In a browser environment, report the browser name.\n      reportedPlatform = _getBrowserName(getUA());\n      break;\n    case ClientPlatform.WORKER:\n      // Technically a worker runs from a browser but we need to differentiate a\n      // worker from a browser.\n      // For example: Chrome-Worker/JsCore/4.9.1/FirebaseCore-web.\n      reportedPlatform = `${_getBrowserName(getUA())}-${clientPlatform}`;\n      break;\n    default:\n      reportedPlatform = clientPlatform;\n  }\n  const reportedFrameworks = frameworks.length\n    ? frameworks.join(',')\n    : 'FirebaseCore-web'; /* default value if no other framework is used */\n  return `${reportedPlatform}/${ClientImplementation.CORE}/${SDK_VERSION}/${reportedFrameworks}`;\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthInternal } from '../../model/auth';\nimport { Unsubscribe, User } from '../../model/public_types';\nimport { AuthErrorCode } from '../errors';\n\ninterface MiddlewareEntry {\n  (user: User | null): Promise<void>;\n  onAbort?: () => void;\n}\n\nexport class AuthMiddlewareQueue {\n  private readonly queue: MiddlewareEntry[] = [];\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  pushCallback(\n    callback: (user: User | null) => void | Promise<void>,\n    onAbort?: () => void\n  ): Unsubscribe {\n    // The callback could be sync or async. Wrap it into a\n    // function that is always async.\n    const wrappedCallback: MiddlewareEntry = (\n      user: User | null\n    ): Promise<void> =>\n      new Promise((resolve, reject) => {\n        try {\n          const result = callback(user);\n          // Either resolve with existing promise or wrap a non-promise\n          // return value into a promise.\n          resolve(result);\n        } catch (e) {\n          // Sync callback throws.\n          reject(e);\n        }\n      });\n    // Attach the onAbort if present\n    wrappedCallback.onAbort = onAbort;\n    this.queue.push(wrappedCallback);\n\n    const index = this.queue.length - 1;\n    return () => {\n      // Unsubscribe. Replace with no-op. Do not remove from array, or it will disturb\n      // indexing of other elements.\n      this.queue[index] = () => Promise.resolve();\n    };\n  }\n\n  async runMiddleware(nextUser: User | null): Promise<void> {\n    if (this.auth.currentUser === nextUser) {\n      return;\n    }\n\n    // While running the middleware, build a temporary stack of onAbort\n    // callbacks to call if one middleware callback rejects.\n\n    const onAbortStack: Array<() => void> = [];\n    try {\n      for (const beforeStateCallback of this.queue) {\n        await beforeStateCallback(nextUser);\n\n        // Only push the onAbort if the callback succeeds\n        if (beforeStateCallback.onAbort) {\n          onAbortStack.push(beforeStateCallback.onAbort);\n        }\n      }\n    } catch (e) {\n      // Run all onAbort, with separate try/catch to ignore any errors and\n      // continue\n      onAbortStack.reverse();\n      for (const onAbort of onAbortStack) {\n        try {\n          onAbort();\n        } catch (_) {\n          /* swallow error */\n        }\n      }\n\n      throw this.auth._errorFactory.create(AuthErrorCode.LOGIN_BLOCKED, {\n        originalMessage: (e as Error)?.message\n      });\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performApiRequest,\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\n/**\n * Request object for fetching the password policy.\n */\nexport interface GetPasswordPolicyRequest {\n  tenantId?: string;\n}\n\n/**\n * Response object for fetching the password policy.\n */\nexport interface GetPasswordPolicyResponse {\n  customStrengthOptions: {\n    minPasswordLength?: number;\n    maxPasswordLength?: number;\n    containsLowercaseCharacter?: boolean;\n    containsUppercaseCharacter?: boolean;\n    containsNumericCharacter?: boolean;\n    containsNonAlphanumericCharacter?: boolean;\n  };\n  allowedNonAlphanumericCharacters?: string[];\n  enforcementState: string;\n  forceUpgradeOnSignin?: boolean;\n  schemaVersion: number;\n}\n\n/**\n * Fetches the password policy for the currently set tenant or the project if no tenant is set.\n *\n * @param auth Auth object.\n * @param request Password policy request.\n * @returns Password policy response.\n */\nexport async function _getPasswordPolicy(\n  auth: Auth,\n  request: GetPasswordPolicyRequest = {}\n): Promise<GetPasswordPolicyResponse> {\n  return _performApiRequest<\n    GetPasswordPolicyRequest,\n    GetPasswordPolicyResponse\n  >(\n    auth,\n    HttpMethod.GET,\n    Endpoint.GET_PASSWORD_POLICY,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { GetPasswordPolicyResponse } from '../../api/password_policy/get_password_policy';\nimport {\n  PasswordPolicyCustomStrengthOptions,\n  PasswordPolicyInternal,\n  PasswordValidationStatusInternal\n} from '../../model/password_policy';\nimport { PasswordValidationStatus } from '../../model/public_types';\n\n// Minimum min password length enforced by the backend, even if no minimum length is set.\nconst MINIMUM_MIN_PASSWORD_LENGTH = 6;\n\n/**\n * Stores password policy requirements and provides password validation against the policy.\n *\n * @internal\n */\nexport class PasswordPolicyImpl implements PasswordPolicyInternal {\n  readonly customStrengthOptions: PasswordPolicyCustomStrengthOptions;\n  readonly allowedNonAlphanumericCharacters: string;\n  readonly enforcementState: string;\n  readonly forceUpgradeOnSignin: boolean;\n  readonly schemaVersion: number;\n\n  constructor(response: GetPasswordPolicyResponse) {\n    // Only include custom strength options defined in the response.\n    const responseOptions = response.customStrengthOptions;\n    this.customStrengthOptions = {};\n    // TODO: Remove once the backend is updated to include the minimum min password length instead of undefined when there is no minimum length set.\n    this.customStrengthOptions.minPasswordLength =\n      responseOptions.minPasswordLength ?? MINIMUM_MIN_PASSWORD_LENGTH;\n    if (responseOptions.maxPasswordLength) {\n      this.customStrengthOptions.maxPasswordLength =\n        responseOptions.maxPasswordLength;\n    }\n    if (responseOptions.containsLowercaseCharacter !== undefined) {\n      this.customStrengthOptions.containsLowercaseLetter =\n        responseOptions.containsLowercaseCharacter;\n    }\n    if (responseOptions.containsUppercaseCharacter !== undefined) {\n      this.customStrengthOptions.containsUppercaseLetter =\n        responseOptions.containsUppercaseCharacter;\n    }\n    if (responseOptions.containsNumericCharacter !== undefined) {\n      this.customStrengthOptions.containsNumericCharacter =\n        responseOptions.containsNumericCharacter;\n    }\n    if (responseOptions.containsNonAlphanumericCharacter !== undefined) {\n      this.customStrengthOptions.containsNonAlphanumericCharacter =\n        responseOptions.containsNonAlphanumericCharacter;\n    }\n\n    this.enforcementState = response.enforcementState;\n    if (this.enforcementState === 'ENFORCEMENT_STATE_UNSPECIFIED') {\n      this.enforcementState = 'OFF';\n    }\n\n    // Use an empty string if no non-alphanumeric characters are specified in the response.\n    this.allowedNonAlphanumericCharacters =\n      response.allowedNonAlphanumericCharacters?.join('') ?? '';\n\n    this.forceUpgradeOnSignin = response.forceUpgradeOnSignin ?? false;\n    this.schemaVersion = response.schemaVersion;\n  }\n\n  validatePassword(password: string): PasswordValidationStatus {\n    const status: PasswordValidationStatusInternal = {\n      isValid: true,\n      passwordPolicy: this\n    };\n\n    // Check the password length and character options.\n    this.validatePasswordLengthOptions(password, status);\n    this.validatePasswordCharacterOptions(password, status);\n\n    // Combine the status into single isValid property.\n    status.isValid &&= status.meetsMinPasswordLength ?? true;\n    status.isValid &&= status.meetsMaxPasswordLength ?? true;\n    status.isValid &&= status.containsLowercaseLetter ?? true;\n    status.isValid &&= status.containsUppercaseLetter ?? true;\n    status.isValid &&= status.containsNumericCharacter ?? true;\n    status.isValid &&= status.containsNonAlphanumericCharacter ?? true;\n\n    return status;\n  }\n\n  /**\n   * Validates that the password meets the length options for the policy.\n   *\n   * @param password Password to validate.\n   * @param status Validation status.\n   */\n  private validatePasswordLengthOptions(\n    password: string,\n    status: PasswordValidationStatusInternal\n  ): void {\n    const minPasswordLength = this.customStrengthOptions.minPasswordLength;\n    const maxPasswordLength = this.customStrengthOptions.maxPasswordLength;\n    if (minPasswordLength) {\n      status.meetsMinPasswordLength = password.length >= minPasswordLength;\n    }\n    if (maxPasswordLength) {\n      status.meetsMaxPasswordLength = password.length <= maxPasswordLength;\n    }\n  }\n\n  /**\n   * Validates that the password meets the character options for the policy.\n   *\n   * @param password Password to validate.\n   * @param status Validation status.\n   */\n  private validatePasswordCharacterOptions(\n    password: string,\n    status: PasswordValidationStatusInternal\n  ): void {\n    // Assign statuses for requirements even if the password is an empty string.\n    this.updatePasswordCharacterOptionsStatuses(\n      status,\n      /* containsLowercaseCharacter= */ false,\n      /* containsUppercaseCharacter= */ false,\n      /* containsNumericCharacter= */ false,\n      /* containsNonAlphanumericCharacter= */ false\n    );\n\n    let passwordChar;\n    for (let i = 0; i < password.length; i++) {\n      passwordChar = password.charAt(i);\n      this.updatePasswordCharacterOptionsStatuses(\n        status,\n        /* containsLowercaseCharacter= */ passwordChar >= 'a' &&\n          passwordChar <= 'z',\n        /* containsUppercaseCharacter= */ passwordChar >= 'A' &&\n          passwordChar <= 'Z',\n        /* containsNumericCharacter= */ passwordChar >= '0' &&\n          passwordChar <= '9',\n        /* containsNonAlphanumericCharacter= */ this.allowedNonAlphanumericCharacters.includes(\n          passwordChar\n        )\n      );\n    }\n  }\n\n  /**\n   * Updates the running validation status with the statuses for the character options.\n   * Expected to be called each time a character is processed to update each option status\n   * based on the current character.\n   *\n   * @param status Validation status.\n   * @param containsLowercaseCharacter Whether the character is a lowercase letter.\n   * @param containsUppercaseCharacter Whether the character is an uppercase letter.\n   * @param containsNumericCharacter Whether the character is a numeric character.\n   * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.\n   */\n  private updatePasswordCharacterOptionsStatuses(\n    status: PasswordValidationStatusInternal,\n    containsLowercaseCharacter: boolean,\n    containsUppercaseCharacter: boolean,\n    containsNumericCharacter: boolean,\n    containsNonAlphanumericCharacter: boolean\n  ): void {\n    if (this.customStrengthOptions.containsLowercaseLetter) {\n      status.containsLowercaseLetter ||= containsLowercaseCharacter;\n    }\n    if (this.customStrengthOptions.containsUppercaseLetter) {\n      status.containsUppercaseLetter ||= containsUppercaseCharacter;\n    }\n    if (this.customStrengthOptions.containsNumericCharacter) {\n      status.containsNumericCharacter ||= containsNumericCharacter;\n    }\n    if (this.customStrengthOptions.containsNonAlphanumericCharacter) {\n      status.containsNonAlphanumericCharacter ||=\n        containsNonAlphanumericCharacter;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _isFirebaseServerApp,\n  _FirebaseService,\n  FirebaseApp\n} from '@firebase/app';\nimport { Provider } from '@firebase/component';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\nimport {\n  Auth,\n  AuthErrorMap,\n  AuthSettings,\n  EmulatorConfig,\n  NextOrObserver,\n  Persistence,\n  PopupRedirectResolver,\n  User,\n  UserCredential,\n  CompleteFn,\n  ErrorFn,\n  NextFn,\n  Unsubscribe,\n  PasswordValidationStatus\n} from '../../model/public_types';\nimport {\n  createSubscribe,\n  ErrorFactory,\n  FirebaseError,\n  getModularInstance,\n  Observer,\n  Subscribe\n} from '@firebase/util';\n\nimport { AuthInternal, ConfigInternal } from '../../model/auth';\nimport { PopupRedirectResolverInternal } from '../../model/popup_redirect';\nimport { UserInternal } from '../../model/user';\nimport {\n  AuthErrorCode,\n  AuthErrorParams,\n  ErrorMapRetriever,\n  _DEFAULT_AUTH_ERROR_FACTORY\n} from '../errors';\nimport { PersistenceInternal } from '../persistence';\nimport {\n  KeyName,\n  PersistenceUserManager\n} from '../persistence/persistence_user_manager';\nimport { _reloadWithoutSaving } from '../user/reload';\nimport {\n  _assert,\n  _serverAppCurrentUserOperationNotSupportedError\n} from '../util/assert';\nimport { _getInstance } from '../util/instantiator';\nimport { _getUserLanguage } from '../util/navigator';\nimport { _getClientVersion } from '../util/version';\nimport { HttpHeader } from '../../api';\nimport {\n  RevokeTokenRequest,\n  TokenType,\n  revokeToken\n} from '../../api/authentication/token';\nimport { AuthMiddlewareQueue } from './middleware';\nimport { RecaptchaConfig } from '../../platform_browser/recaptcha/recaptcha';\nimport { _logWarn } from '../util/log';\nimport { _getPasswordPolicy } from '../../api/password_policy/get_password_policy';\nimport { PasswordPolicyInternal } from '../../model/password_policy';\nimport { PasswordPolicyImpl } from './password_policy_impl';\nimport { getAccountInfo } from '../../api/account_management/account';\nimport { UserImpl } from '../user/user_impl';\n\ninterface AsyncAction {\n  (): Promise<void>;\n}\n\nexport const enum DefaultConfig {\n  TOKEN_API_HOST = 'securetoken.googleapis.com',\n  API_HOST = 'identitytoolkit.googleapis.com',\n  API_SCHEME = 'https'\n}\n\nexport class AuthImpl implements AuthInternal, _FirebaseService {\n  currentUser: User | null = null;\n  emulatorConfig: EmulatorConfig | null = null;\n  private operations = Promise.resolve();\n  private persistenceManager?: PersistenceUserManager;\n  private redirectPersistenceManager?: PersistenceUserManager;\n  private authStateSubscription = new Subscription<User>(this);\n  private idTokenSubscription = new Subscription<User>(this);\n  private readonly beforeStateQueue = new AuthMiddlewareQueue(this);\n  private redirectUser: UserInternal | null = null;\n  private isProactiveRefreshEnabled = false;\n  private readonly EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION: number = 1;\n\n  // Any network calls will set this to true and prevent subsequent emulator\n  // initialization\n  _canInitEmulator = true;\n  _isInitialized = false;\n  _deleted = false;\n  _initializationPromise: Promise<void> | null = null;\n  _popupRedirectResolver: PopupRedirectResolverInternal | null = null;\n  _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams> =\n    _DEFAULT_AUTH_ERROR_FACTORY;\n  _agentRecaptchaConfig: RecaptchaConfig | null = null;\n  _tenantRecaptchaConfigs: Record<string, RecaptchaConfig> = {};\n  _projectPasswordPolicy: PasswordPolicyInternal | null = null;\n  _tenantPasswordPolicies: Record<string, PasswordPolicyInternal> = {};\n  _resolvePersistenceManagerAvailable:\n    | ((value: void | PromiseLike<void>) => void)\n    | undefined = undefined;\n  _persistenceManagerAvailable: Promise<void>;\n  readonly name: string;\n\n  // Tracks the last notified UID for state change listeners to prevent\n  // repeated calls to the callbacks. Undefined means it's never been\n  // called, whereas null means it's been called with a signed out user\n  private lastNotifiedUid: string | null | undefined = undefined;\n\n  languageCode: string | null = null;\n  tenantId: string | null = null;\n  settings: AuthSettings = { appVerificationDisabledForTesting: false };\n\n  constructor(\n    public readonly app: FirebaseApp,\n    private readonly heartbeatServiceProvider: Provider<'heartbeat'>,\n    private readonly appCheckServiceProvider: Provider<AppCheckInternalComponentName>,\n    public readonly config: ConfigInternal\n  ) {\n    this.name = app.name;\n    this.clientVersion = config.sdkClientVersion;\n    // TODO(jamesdaniels) explore less hacky way to do this, cookie authentication needs\n    // persistenceMananger to be available. see _getFinalTarget for more context\n    this._persistenceManagerAvailable = new Promise<void>(\n      resolve => (this._resolvePersistenceManagerAvailable = resolve)\n    );\n  }\n\n  _initializeWithPersistence(\n    persistenceHierarchy: PersistenceInternal[],\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    if (popupRedirectResolver) {\n      this._popupRedirectResolver = _getInstance(popupRedirectResolver);\n    }\n\n    // Have to check for app deletion throughout initialization (after each\n    // promise resolution)\n    this._initializationPromise = this.queue(async () => {\n      if (this._deleted) {\n        return;\n      }\n\n      this.persistenceManager = await PersistenceUserManager.create(\n        this,\n        persistenceHierarchy\n      );\n      this._resolvePersistenceManagerAvailable?.();\n\n      if (this._deleted) {\n        return;\n      }\n\n      // Initialize the resolver early if necessary (only applicable to web:\n      // this will cause the iframe to load immediately in certain cases)\n      if (this._popupRedirectResolver?._shouldInitProactively) {\n        // If this fails, don't halt auth loading\n        try {\n          await this._popupRedirectResolver._initialize(this);\n        } catch (e) {\n          /* Ignore the error */\n        }\n      }\n\n      await this.initializeCurrentUser(popupRedirectResolver);\n\n      this.lastNotifiedUid = this.currentUser?.uid || null;\n\n      if (this._deleted) {\n        return;\n      }\n\n      this._isInitialized = true;\n    });\n\n    return this._initializationPromise;\n  }\n\n  /**\n   * If the persistence is changed in another window, the user manager will let us know\n   */\n  async _onStorageEvent(): Promise<void> {\n    if (this._deleted) {\n      return;\n    }\n\n    const user = await this.assertedPersistence.getCurrentUser();\n\n    if (!this.currentUser && !user) {\n      // No change, do nothing (was signed out and remained signed out).\n      return;\n    }\n\n    // If the same user is to be synchronized.\n    if (this.currentUser && user && this.currentUser.uid === user.uid) {\n      // Data update, simply copy data changes.\n      this._currentUser._assign(user);\n      // If tokens changed from previous user tokens, this will trigger\n      // notifyAuthListeners_.\n      await this.currentUser.getIdToken();\n      return;\n    }\n\n    // Update current Auth state. Either a new login or logout.\n    // Skip blocking callbacks, they should not apply to a change in another tab.\n    await this._updateCurrentUser(user, /* skipBeforeStateCallbacks */ true);\n  }\n\n  private async initializeCurrentUserFromIdToken(\n    idToken: string\n  ): Promise<void> {\n    try {\n      const response = await getAccountInfo(this, { idToken });\n      const user = await UserImpl._fromGetAccountInfoResponse(\n        this,\n        response,\n        idToken\n      );\n      await this.directlySetCurrentUser(user);\n    } catch (err) {\n      console.warn(\n        'FirebaseServerApp could not login user with provided authIdToken: ',\n        err\n      );\n      await this.directlySetCurrentUser(null);\n    }\n  }\n\n  private async initializeCurrentUser(\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      const idToken = this.app.settings.authIdToken;\n      if (idToken) {\n        // Start the auth operation in the next tick to allow a moment for the customer's app to\n        // attach an emulator, if desired.\n        return new Promise<void>(resolve => {\n          setTimeout(() =>\n            this.initializeCurrentUserFromIdToken(idToken).then(\n              resolve,\n              resolve\n            )\n          );\n        });\n      } else {\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    // First check to see if we have a pending redirect event.\n    const previouslyStoredUser =\n      (await this.assertedPersistence.getCurrentUser()) as UserInternal | null;\n    let futureCurrentUser = previouslyStoredUser;\n    let needsTocheckMiddleware = false;\n    if (popupRedirectResolver && this.config.authDomain) {\n      await this.getOrInitRedirectPersistenceManager();\n      const redirectUserEventId = this.redirectUser?._redirectEventId;\n      const storedUserEventId = futureCurrentUser?._redirectEventId;\n      const result = await this.tryRedirectSignIn(popupRedirectResolver);\n\n      // If the stored user (i.e. the old \"currentUser\") has a redirectId that\n      // matches the redirect user, then we want to initially sign in with the\n      // new user object from result.\n      // TODO(samgho): More thoroughly test all of this\n      if (\n        (!redirectUserEventId || redirectUserEventId === storedUserEventId) &&\n        result?.user\n      ) {\n        futureCurrentUser = result.user as UserInternal;\n        needsTocheckMiddleware = true;\n      }\n    }\n\n    // If no user in persistence, there is no current user. Set to null.\n    if (!futureCurrentUser) {\n      return this.directlySetCurrentUser(null);\n    }\n\n    if (!futureCurrentUser._redirectEventId) {\n      // This isn't a redirect link operation, we can reload and bail.\n      // First though, ensure that we check the middleware is happy.\n      if (needsTocheckMiddleware) {\n        try {\n          await this.beforeStateQueue.runMiddleware(futureCurrentUser);\n        } catch (e) {\n          futureCurrentUser = previouslyStoredUser;\n          // We know this is available since the bit is only set when the\n          // resolver is available\n          this._popupRedirectResolver!._overrideRedirectResult(this, () =>\n            Promise.reject(e)\n          );\n        }\n      }\n\n      if (futureCurrentUser) {\n        return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);\n      } else {\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    _assert(this._popupRedirectResolver, this, AuthErrorCode.ARGUMENT_ERROR);\n    await this.getOrInitRedirectPersistenceManager();\n\n    // If the redirect user's event ID matches the current user's event ID,\n    // DO NOT reload the current user, otherwise they'll be cleared from storage.\n    // This is important for the reauthenticateWithRedirect() flow.\n    if (\n      this.redirectUser &&\n      this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId\n    ) {\n      return this.directlySetCurrentUser(futureCurrentUser);\n    }\n\n    return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);\n  }\n\n  private async tryRedirectSignIn(\n    redirectResolver: PopupRedirectResolver\n  ): Promise<UserCredential | null> {\n    // The redirect user needs to be checked (and signed in if available)\n    // during auth initialization. All of the normal sign in and link/reauth\n    // flows call back into auth and push things onto the promise queue. We\n    // need to await the result of the redirect sign in *inside the promise\n    // queue*. This presents a problem: we run into deadlock. See:\n    //    ┌> [Initialization] ─────┐\n    //    ┌> [<other queue tasks>] │\n    //    └─ [getRedirectResult] <─┘\n    //    where [] are tasks on the queue and arrows denote awaits\n    // Initialization will never complete because it's waiting on something\n    // that's waiting for initialization to complete!\n    //\n    // Instead, this method calls getRedirectResult() (stored in\n    // _completeRedirectFn) with an optional parameter that instructs all of\n    // the underlying auth operations to skip anything that mutates auth state.\n\n    let result: UserCredential | null = null;\n    try {\n      // We know this._popupRedirectResolver is set since redirectResolver\n      // is passed in. The _completeRedirectFn expects the unwrapped extern.\n      result = await this._popupRedirectResolver!._completeRedirectFn(\n        this,\n        redirectResolver,\n        true\n      );\n    } catch (e) {\n      // Swallow any errors here; the code can retrieve them in\n      // getRedirectResult().\n      await this._setRedirectUser(null);\n    }\n\n    return result;\n  }\n\n  private async reloadAndSetCurrentUserOrClear(\n    user: UserInternal\n  ): Promise<void> {\n    try {\n      await _reloadWithoutSaving(user);\n    } catch (e) {\n      if (\n        (e as FirebaseError)?.code !==\n        `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`\n      ) {\n        // Something's wrong with the user's token. Log them out and remove\n        // them from storage\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    return this.directlySetCurrentUser(user);\n  }\n\n  useDeviceLanguage(): void {\n    this.languageCode = _getUserLanguage();\n  }\n\n  async _delete(): Promise<void> {\n    this._deleted = true;\n  }\n\n  async updateCurrentUser(userExtern: User | null): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this)\n      );\n    }\n    // The public updateCurrentUser method needs to make a copy of the user,\n    // and also check that the project matches\n    const user = userExtern\n      ? (getModularInstance(userExtern) as UserInternal)\n      : null;\n    if (user) {\n      _assert(\n        user.auth.config.apiKey === this.config.apiKey,\n        this,\n        AuthErrorCode.INVALID_AUTH\n      );\n    }\n    return this._updateCurrentUser(user && user._clone(this));\n  }\n\n  async _updateCurrentUser(\n    user: User | null,\n    skipBeforeStateCallbacks: boolean = false\n  ): Promise<void> {\n    if (this._deleted) {\n      return;\n    }\n    if (user) {\n      _assert(\n        this.tenantId === user.tenantId,\n        this,\n        AuthErrorCode.TENANT_ID_MISMATCH\n      );\n    }\n\n    if (!skipBeforeStateCallbacks) {\n      await this.beforeStateQueue.runMiddleware(user);\n    }\n\n    return this.queue(async () => {\n      await this.directlySetCurrentUser(user as UserInternal | null);\n      this.notifyAuthListeners();\n    });\n  }\n\n  async signOut(): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this)\n      );\n    }\n    // Run first, to block _setRedirectUser() if any callbacks fail.\n    await this.beforeStateQueue.runMiddleware(null);\n    // Clear the redirect user when signOut is called\n    if (this.redirectPersistenceManager || this._popupRedirectResolver) {\n      await this._setRedirectUser(null);\n    }\n\n    // Prevent callbacks from being called again in _updateCurrentUser, as\n    // they were already called in the first line.\n    return this._updateCurrentUser(null, /* skipBeforeStateCallbacks */ true);\n  }\n\n  setPersistence(persistence: Persistence): Promise<void> {\n    if (_isFirebaseServerApp(this.app)) {\n      return Promise.reject(\n        _serverAppCurrentUserOperationNotSupportedError(this)\n      );\n    }\n    return this.queue(async () => {\n      await this.assertedPersistence.setPersistence(_getInstance(persistence));\n    });\n  }\n\n  _getRecaptchaConfig(): RecaptchaConfig | null {\n    if (this.tenantId == null) {\n      return this._agentRecaptchaConfig;\n    } else {\n      return this._tenantRecaptchaConfigs[this.tenantId];\n    }\n  }\n\n  async validatePassword(password: string): Promise<PasswordValidationStatus> {\n    if (!this._getPasswordPolicyInternal()) {\n      await this._updatePasswordPolicy();\n    }\n\n    // Password policy will be defined after fetching.\n    const passwordPolicy: PasswordPolicyInternal =\n      this._getPasswordPolicyInternal()!;\n\n    // Check that the policy schema version is supported by the SDK.\n    // TODO: Update this logic to use a max supported policy schema version once we have multiple schema versions.\n    if (\n      passwordPolicy.schemaVersion !==\n      this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION\n    ) {\n      return Promise.reject(\n        this._errorFactory.create(\n          AuthErrorCode.UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION,\n          {}\n        )\n      );\n    }\n\n    return passwordPolicy.validatePassword(password);\n  }\n\n  _getPasswordPolicyInternal(): PasswordPolicyInternal | null {\n    if (this.tenantId === null) {\n      return this._projectPasswordPolicy;\n    } else {\n      return this._tenantPasswordPolicies[this.tenantId];\n    }\n  }\n\n  async _updatePasswordPolicy(): Promise<void> {\n    const response = await _getPasswordPolicy(this);\n\n    const passwordPolicy: PasswordPolicyInternal = new PasswordPolicyImpl(\n      response\n    );\n\n    if (this.tenantId === null) {\n      this._projectPasswordPolicy = passwordPolicy;\n    } else {\n      this._tenantPasswordPolicies[this.tenantId] = passwordPolicy;\n    }\n  }\n\n  _getPersistenceType(): string {\n    return this.assertedPersistence.persistence.type;\n  }\n\n  _getPersistence(): PersistenceInternal {\n    return this.assertedPersistence.persistence;\n  }\n\n  _updateErrorMap(errorMap: AuthErrorMap): void {\n    this._errorFactory = new ErrorFactory<AuthErrorCode, AuthErrorParams>(\n      'auth',\n      'Firebase',\n      (errorMap as ErrorMapRetriever)()\n    );\n  }\n\n  onAuthStateChanged(\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    return this.registerStateListener(\n      this.authStateSubscription,\n      nextOrObserver,\n      error,\n      completed\n    );\n  }\n\n  beforeAuthStateChanged(\n    callback: (user: User | null) => void | Promise<void>,\n    onAbort?: () => void\n  ): Unsubscribe {\n    return this.beforeStateQueue.pushCallback(callback, onAbort);\n  }\n\n  onIdTokenChanged(\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    return this.registerStateListener(\n      this.idTokenSubscription,\n      nextOrObserver,\n      error,\n      completed\n    );\n  }\n\n  authStateReady(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if (this.currentUser) {\n        resolve();\n      } else {\n        const unsubscribe = this.onAuthStateChanged(() => {\n          unsubscribe();\n          resolve();\n        }, reject);\n      }\n    });\n  }\n\n  /**\n   * Revokes the given access token. Currently only supports Apple OAuth access tokens.\n   */\n  async revokeAccessToken(token: string): Promise<void> {\n    if (this.currentUser) {\n      const idToken = await this.currentUser.getIdToken();\n      // Generalize this to accept other providers once supported.\n      const request: RevokeTokenRequest = {\n        providerId: 'apple.com',\n        tokenType: TokenType.ACCESS_TOKEN,\n        token,\n        idToken\n      };\n      if (this.tenantId != null) {\n        request.tenantId = this.tenantId;\n      }\n      await revokeToken(this, request);\n    }\n  }\n\n  toJSON(): object {\n    return {\n      apiKey: this.config.apiKey,\n      authDomain: this.config.authDomain,\n      appName: this.name,\n      currentUser: this._currentUser?.toJSON()\n    };\n  }\n\n  async _setRedirectUser(\n    user: UserInternal | null,\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    const redirectManager = await this.getOrInitRedirectPersistenceManager(\n      popupRedirectResolver\n    );\n    return user === null\n      ? redirectManager.removeCurrentUser()\n      : redirectManager.setCurrentUser(user);\n  }\n\n  private async getOrInitRedirectPersistenceManager(\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<PersistenceUserManager> {\n    if (!this.redirectPersistenceManager) {\n      const resolver: PopupRedirectResolverInternal | null =\n        (popupRedirectResolver && _getInstance(popupRedirectResolver)) ||\n        this._popupRedirectResolver;\n      _assert(resolver, this, AuthErrorCode.ARGUMENT_ERROR);\n      this.redirectPersistenceManager = await PersistenceUserManager.create(\n        this,\n        [_getInstance(resolver._redirectPersistence)],\n        KeyName.REDIRECT_USER\n      );\n      this.redirectUser =\n        await this.redirectPersistenceManager.getCurrentUser();\n    }\n\n    return this.redirectPersistenceManager;\n  }\n\n  async _redirectUserForId(id: string): Promise<UserInternal | null> {\n    // Make sure we've cleared any pending persistence actions if we're not in\n    // the initializer\n    if (this._isInitialized) {\n      await this.queue(async () => {});\n    }\n\n    if (this._currentUser?._redirectEventId === id) {\n      return this._currentUser;\n    }\n\n    if (this.redirectUser?._redirectEventId === id) {\n      return this.redirectUser;\n    }\n\n    return null;\n  }\n\n  async _persistUserIfCurrent(user: UserInternal): Promise<void> {\n    if (user === this.currentUser) {\n      return this.queue(async () => this.directlySetCurrentUser(user));\n    }\n  }\n\n  /** Notifies listeners only if the user is current */\n  _notifyListenersIfCurrent(user: UserInternal): void {\n    if (user === this.currentUser) {\n      this.notifyAuthListeners();\n    }\n  }\n\n  _key(): string {\n    return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;\n  }\n\n  _startProactiveRefresh(): void {\n    this.isProactiveRefreshEnabled = true;\n    if (this.currentUser) {\n      this._currentUser._startProactiveRefresh();\n    }\n  }\n\n  _stopProactiveRefresh(): void {\n    this.isProactiveRefreshEnabled = false;\n    if (this.currentUser) {\n      this._currentUser._stopProactiveRefresh();\n    }\n  }\n\n  /** Returns the current user cast as the internal type */\n  get _currentUser(): UserInternal {\n    return this.currentUser as UserInternal;\n  }\n\n  private notifyAuthListeners(): void {\n    if (!this._isInitialized) {\n      return;\n    }\n\n    this.idTokenSubscription.next(this.currentUser);\n\n    const currentUid = this.currentUser?.uid ?? null;\n    if (this.lastNotifiedUid !== currentUid) {\n      this.lastNotifiedUid = currentUid;\n      this.authStateSubscription.next(this.currentUser);\n    }\n  }\n\n  private registerStateListener(\n    subscription: Subscription<User>,\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    if (this._deleted) {\n      return () => {};\n    }\n\n    const cb =\n      typeof nextOrObserver === 'function'\n        ? nextOrObserver\n        : nextOrObserver.next.bind(nextOrObserver);\n\n    let isUnsubscribed = false;\n\n    const promise = this._isInitialized\n      ? Promise.resolve()\n      : this._initializationPromise;\n    _assert(promise, this, AuthErrorCode.INTERNAL_ERROR);\n    // The callback needs to be called asynchronously per the spec.\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    promise.then(() => {\n      if (isUnsubscribed) {\n        return;\n      }\n      cb(this.currentUser);\n    });\n\n    if (typeof nextOrObserver === 'function') {\n      const unsubscribe = subscription.addObserver(\n        nextOrObserver,\n        error,\n        completed\n      );\n      return () => {\n        isUnsubscribed = true;\n        unsubscribe();\n      };\n    } else {\n      const unsubscribe = subscription.addObserver(nextOrObserver);\n      return () => {\n        isUnsubscribed = true;\n        unsubscribe();\n      };\n    }\n  }\n\n  /**\n   * Unprotected (from race conditions) method to set the current user. This\n   * should only be called from within a queued callback. This is necessary\n   * because the queue shouldn't rely on another queued callback.\n   */\n  private async directlySetCurrentUser(\n    user: UserInternal | null\n  ): Promise<void> {\n    if (this.currentUser && this.currentUser !== user) {\n      this._currentUser._stopProactiveRefresh();\n    }\n    if (user && this.isProactiveRefreshEnabled) {\n      user._startProactiveRefresh();\n    }\n\n    this.currentUser = user;\n\n    if (user) {\n      await this.assertedPersistence.setCurrentUser(user);\n    } else {\n      await this.assertedPersistence.removeCurrentUser();\n    }\n  }\n\n  private queue(action: AsyncAction): Promise<void> {\n    // In case something errors, the callback still should be called in order\n    // to keep the promise chain alive\n    this.operations = this.operations.then(action, action);\n    return this.operations;\n  }\n\n  private get assertedPersistence(): PersistenceUserManager {\n    _assert(this.persistenceManager, this, AuthErrorCode.INTERNAL_ERROR);\n    return this.persistenceManager;\n  }\n\n  private frameworks: string[] = [];\n  private clientVersion: string;\n  _logFramework(framework: string): void {\n    if (!framework || this.frameworks.includes(framework)) {\n      return;\n    }\n    this.frameworks.push(framework);\n\n    // Sort alphabetically so that \"FirebaseCore-web,FirebaseUI-web\" and\n    // \"FirebaseUI-web,FirebaseCore-web\" aren't viewed as different.\n    this.frameworks.sort();\n    this.clientVersion = _getClientVersion(\n      this.config.clientPlatform,\n      this._getFrameworks()\n    );\n  }\n  _getFrameworks(): readonly string[] {\n    return this.frameworks;\n  }\n  async _getAdditionalHeaders(): Promise<Record<string, string>> {\n    // Additional headers on every request\n    const headers: Record<string, string> = {\n      [HttpHeader.X_CLIENT_VERSION]: this.clientVersion\n    };\n\n    if (this.app.options.appId) {\n      headers[HttpHeader.X_FIREBASE_GMPID] = this.app.options.appId;\n    }\n\n    // If the heartbeat service exists, add the heartbeat string\n    const heartbeatsHeader = await this.heartbeatServiceProvider\n      .getImmediate({\n        optional: true\n      })\n      ?.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers[HttpHeader.X_FIREBASE_CLIENT] = heartbeatsHeader;\n    }\n\n    // If the App Check service exists, add the App Check token in the headers\n    const appCheckToken = await this._getAppCheckToken();\n    if (appCheckToken) {\n      headers[HttpHeader.X_FIREBASE_APP_CHECK] = appCheckToken;\n    }\n\n    return headers;\n  }\n\n  async _getAppCheckToken(): Promise<string | undefined> {\n    if (_isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {\n      return this.app.settings.appCheckToken;\n    }\n    const appCheckTokenResult = await this.appCheckServiceProvider\n      .getImmediate({ optional: true })\n      ?.getToken();\n    if (appCheckTokenResult?.error) {\n      // Context: appCheck.getToken() will never throw even if an error happened.\n      // In the error case, a dummy token will be returned along with an error field describing\n      // the error. In general, we shouldn't care about the error condition and just use\n      // the token (actual or dummy) to send requests.\n      _logWarn(\n        `Error while retrieving App Check token: ${appCheckTokenResult.error}`\n      );\n    }\n    return appCheckTokenResult?.token;\n  }\n}\n\n/**\n * Method to be used to cast down to our private implementation of Auth.\n * It will also handle unwrapping from the compat type if necessary\n *\n * @param auth Auth object passed in from developer\n */\nexport function _castAuth(auth: Auth): AuthInternal {\n  return getModularInstance(auth) as AuthInternal;\n}\n\n/** Helper class to wrap subscriber logic */\nclass Subscription<T> {\n  private observer: Observer<T | null> | null = null;\n  readonly addObserver: Subscribe<T | null> = createSubscribe(\n    observer => (this.observer = observer)\n  );\n\n  constructor(readonly auth: AuthInternal) {}\n\n  get next(): NextFn<T | null> {\n    _assert(this.observer, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    return this.observer.next.bind(this.observer);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\ninterface ExternalJSProvider {\n  loadJS(url: string): Promise<Event>;\n  recaptchaV2Script: string;\n  recaptchaEnterpriseScript: string;\n  gapiScript: string;\n}\n\nlet externalJSProvider: ExternalJSProvider = {\n  async loadJS() {\n    throw new Error('Unable to load external scripts');\n  },\n\n  recaptchaV2Script: '',\n  recaptchaEnterpriseScript: '',\n  gapiScript: ''\n};\n\nexport function _setExternalJSProvider(p: ExternalJSProvider): void {\n  externalJSProvider = p;\n}\n\nexport function _loadJS(url: string): Promise<Event> {\n  return externalJSProvider.loadJS(url);\n}\n\nexport function _recaptchaV2ScriptUrl(): string {\n  return externalJSProvider.recaptchaV2Script;\n}\n\nexport function _recaptchaEnterpriseScriptUrl(): string {\n  return externalJSProvider.recaptchaEnterpriseScript;\n}\n\nexport function _gapiScriptUrl(): string {\n  return externalJSProvider.gapiScript;\n}\n\nexport function _generateCallbackName(prefix: string): string {\n  return `__${prefix}${Math.floor(Math.random() * 1000000)}`;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\nimport { AuthInternal } from '../../model/auth';\nimport { RecaptchaParameters } from '../../model/public_types';\nimport {\n  Recaptcha,\n  GreCAPTCHATopLevel,\n  GreCAPTCHARenderOption,\n  GreCAPTCHA\n} from './recaptcha';\n\nexport const _SOLVE_TIME_MS = 500;\nexport const _EXPIRATION_TIME_MS = 60_000;\nexport const _WIDGET_ID_START = 1_000_000_000_000;\n\nexport interface Widget {\n  getResponse: () => string | null;\n  delete: () => void;\n  execute: () => void;\n}\n\nexport class MockReCaptcha implements Recaptcha {\n  private counter = _WIDGET_ID_START;\n  _widgets = new Map<number, Widget>();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  render(\n    container: string | HTMLElement,\n    parameters?: RecaptchaParameters\n  ): number {\n    const id = this.counter;\n    this._widgets.set(\n      id,\n      new MockWidget(container, this.auth.name, parameters || {})\n    );\n    this.counter++;\n    return id;\n  }\n\n  reset(optWidgetId?: number): void {\n    const id = optWidgetId || _WIDGET_ID_START;\n    void this._widgets.get(id)?.delete();\n    this._widgets.delete(id);\n  }\n\n  getResponse(optWidgetId?: number): string {\n    const id = optWidgetId || _WIDGET_ID_START;\n    return this._widgets.get(id)?.getResponse() || '';\n  }\n\n  async execute(optWidgetId?: number | string): Promise<string> {\n    const id: number = (optWidgetId as number) || _WIDGET_ID_START;\n    void this._widgets.get(id)?.execute();\n    return '';\n  }\n}\n\nexport class MockGreCAPTCHATopLevel implements GreCAPTCHATopLevel {\n  enterprise: GreCAPTCHA = new MockGreCAPTCHA();\n  ready(callback: () => void): void {\n    callback();\n  }\n\n  execute(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _siteKey: string,\n    _options: { action: string }\n  ): Promise<string> {\n    return Promise.resolve('token');\n  }\n  render(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _container: string | HTMLElement,\n    _parameters: GreCAPTCHARenderOption\n  ): string {\n    return '';\n  }\n}\n\nexport class MockGreCAPTCHA implements GreCAPTCHA {\n  ready(callback: () => void): void {\n    callback();\n  }\n\n  execute(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _siteKey: string,\n    _options: { action: string }\n  ): Promise<string> {\n    return Promise.resolve('token');\n  }\n  render(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _container: string | HTMLElement,\n    _parameters: GreCAPTCHARenderOption\n  ): string {\n    return '';\n  }\n}\n\nexport class MockWidget {\n  private readonly container: HTMLElement;\n  private readonly isVisible: boolean;\n  private timerId: number | null = null;\n  private deleted = false;\n  private responseToken: string | null = null;\n  private readonly clickHandler = (): void => {\n    this.execute();\n  };\n\n  constructor(\n    containerOrId: string | HTMLElement,\n    appName: string,\n    private readonly params: RecaptchaParameters\n  ) {\n    const container =\n      typeof containerOrId === 'string'\n        ? document.getElementById(containerOrId)\n        : containerOrId;\n    _assert(container, AuthErrorCode.ARGUMENT_ERROR, { appName });\n\n    this.container = container;\n    this.isVisible = this.params.size !== 'invisible';\n    if (this.isVisible) {\n      this.execute();\n    } else {\n      this.container.addEventListener('click', this.clickHandler);\n    }\n  }\n\n  getResponse(): string | null {\n    this.checkIfDeleted();\n    return this.responseToken;\n  }\n\n  delete(): void {\n    this.checkIfDeleted();\n    this.deleted = true;\n    if (this.timerId) {\n      clearTimeout(this.timerId);\n      this.timerId = null;\n    }\n    this.container.removeEventListener('click', this.clickHandler);\n  }\n\n  execute(): void {\n    this.checkIfDeleted();\n    if (this.timerId) {\n      return;\n    }\n\n    this.timerId = window.setTimeout(() => {\n      this.responseToken = generateRandomAlphaNumericString(50);\n      const { callback, 'expired-callback': expiredCallback } = this.params;\n      if (callback) {\n        try {\n          callback(this.responseToken);\n        } catch (e) {}\n      }\n\n      this.timerId = window.setTimeout(() => {\n        this.timerId = null;\n        this.responseToken = null;\n        if (expiredCallback) {\n          try {\n            expiredCallback();\n          } catch (e) {}\n        }\n\n        if (this.isVisible) {\n          this.execute();\n        }\n      }, _EXPIRATION_TIME_MS);\n    }, _SOLVE_TIME_MS);\n  }\n\n  private checkIfDeleted(): void {\n    if (this.deleted) {\n      throw new Error('reCAPTCHA mock was already deleted!');\n    }\n  }\n}\n\nfunction generateRandomAlphaNumericString(len: number): string {\n  const chars = [];\n  const allowedChars =\n    '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\n  for (let i = 0; i < len; i++) {\n    chars.push(\n      allowedChars.charAt(Math.floor(Math.random() * allowedChars.length))\n    );\n  }\n  return chars.join('');\n}\n", "/* eslint-disable @typescript-eslint/no-require-imports */\n/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isEnterprise, RecaptchaConfig } from './recaptcha';\nimport { getRecaptchaConfig } from '../../api/authentication/recaptcha';\nimport {\n  RecaptchaClientType,\n  RecaptchaVersion,\n  RecaptchaActionName,\n  RecaptchaAuthProvider,\n  EnforcementState\n} from '../../api';\n\nimport { Auth } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport * as jsHelpers from '../load_js';\nimport { AuthErrorCode } from '../../core/errors';\nimport { StartPhoneMfaEnrollmentRequest } from '../../api/account_management/mfa';\nimport { StartPhoneMfaSignInRequest } from '../../api/authentication/mfa';\nimport { MockGreCAPTCHATopLevel } from './recaptcha_mock';\n\nexport const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = 'recaptcha-enterprise';\nexport const FAKE_TOKEN = 'NO_RECAPTCHA';\n\nexport class RecaptchaEnterpriseVerifier {\n  /**\n   * Identifies the type of application verifier (e.g. \"recaptcha-enterprise\").\n   */\n  readonly type = RECAPTCHA_ENTERPRISE_VERIFIER_TYPE;\n\n  private readonly auth: AuthInternal;\n\n  /**\n   *\n   * @param authExtern - The corresponding Firebase {@link Auth} instance.\n   *\n   */\n  constructor(authExtern: Auth) {\n    this.auth = _castAuth(authExtern);\n  }\n\n  /**\n   * Executes the verification process.\n   *\n   * @returns A Promise for a token that can be used to assert the validity of a request.\n   */\n  async verify(\n    action: string = 'verify',\n    forceRefresh = false\n  ): Promise<string> {\n    async function retrieveSiteKey(auth: AuthInternal): Promise<string> {\n      if (!forceRefresh) {\n        if (auth.tenantId == null && auth._agentRecaptchaConfig != null) {\n          return auth._agentRecaptchaConfig.siteKey;\n        }\n        if (\n          auth.tenantId != null &&\n          auth._tenantRecaptchaConfigs[auth.tenantId] !== undefined\n        ) {\n          return auth._tenantRecaptchaConfigs[auth.tenantId].siteKey;\n        }\n      }\n\n      return new Promise<string>(async (resolve, reject) => {\n        getRecaptchaConfig(auth, {\n          clientType: RecaptchaClientType.WEB,\n          version: RecaptchaVersion.ENTERPRISE\n        })\n          .then(response => {\n            if (response.recaptchaKey === undefined) {\n              reject(new Error('recaptcha Enterprise site key undefined'));\n            } else {\n              const config = new RecaptchaConfig(response);\n              if (auth.tenantId == null) {\n                auth._agentRecaptchaConfig = config;\n              } else {\n                auth._tenantRecaptchaConfigs[auth.tenantId] = config;\n              }\n              return resolve(config.siteKey);\n            }\n          })\n          .catch(error => {\n            reject(error);\n          });\n      });\n    }\n\n    function retrieveRecaptchaToken(\n      siteKey: string,\n      resolve: (value: string | PromiseLike<string>) => void,\n      reject: (reason?: unknown) => void\n    ): void {\n      const grecaptcha = window.grecaptcha;\n      if (isEnterprise(grecaptcha)) {\n        grecaptcha.enterprise.ready(() => {\n          grecaptcha.enterprise\n            .execute(siteKey, { action })\n            .then(token => {\n              resolve(token);\n            })\n            .catch(() => {\n              resolve(FAKE_TOKEN);\n            });\n        });\n      } else {\n        reject(Error('No reCAPTCHA enterprise script loaded.'));\n      }\n    }\n\n    // Returns Promise for a mock token when appVerificationDisabledForTesting is true.\n    if (this.auth.settings.appVerificationDisabledForTesting) {\n      const mockRecaptcha = new MockGreCAPTCHATopLevel();\n      return mockRecaptcha.execute('siteKey', { action: 'verify' });\n    }\n\n    return new Promise<string>((resolve, reject) => {\n      retrieveSiteKey(this.auth)\n        .then(siteKey => {\n          if (!forceRefresh && isEnterprise(window.grecaptcha)) {\n            retrieveRecaptchaToken(siteKey, resolve, reject);\n          } else {\n            if (typeof window === 'undefined') {\n              reject(\n                new Error('RecaptchaVerifier is only supported in browser')\n              );\n              return;\n            }\n            let url = jsHelpers._recaptchaEnterpriseScriptUrl();\n            if (url.length !== 0) {\n              url += siteKey;\n            }\n            jsHelpers\n              ._loadJS(url)\n              .then(() => {\n                retrieveRecaptchaToken(siteKey, resolve, reject);\n              })\n              .catch(error => {\n                reject(error);\n              });\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  }\n}\n\nexport async function injectRecaptchaFields<T extends object>(\n  auth: AuthInternal,\n  request: T,\n  action: RecaptchaActionName,\n  isCaptchaResp = false,\n  isFakeToken = false\n): Promise<T> {\n  const verifier = new RecaptchaEnterpriseVerifier(auth);\n  let captchaResponse;\n\n  if (isFakeToken) {\n    captchaResponse = FAKE_TOKEN;\n  } else {\n    try {\n      captchaResponse = await verifier.verify(action);\n    } catch (error) {\n      captchaResponse = await verifier.verify(action, true);\n    }\n  }\n\n  const newRequest = { ...request };\n  if (\n    action === RecaptchaActionName.MFA_SMS_ENROLLMENT ||\n    action === RecaptchaActionName.MFA_SMS_SIGNIN\n  ) {\n    if ('phoneEnrollmentInfo' in newRequest) {\n      const phoneNumber = (\n        newRequest as unknown as StartPhoneMfaEnrollmentRequest\n      ).phoneEnrollmentInfo.phoneNumber;\n      const recaptchaToken = (\n        newRequest as unknown as StartPhoneMfaEnrollmentRequest\n      ).phoneEnrollmentInfo.recaptchaToken;\n\n      Object.assign(newRequest, {\n        'phoneEnrollmentInfo': {\n          phoneNumber,\n          recaptchaToken,\n          captchaResponse,\n          'clientType': RecaptchaClientType.WEB,\n          'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n        }\n      });\n    } else if ('phoneSignInInfo' in newRequest) {\n      const recaptchaToken = (\n        newRequest as unknown as StartPhoneMfaSignInRequest\n      ).phoneSignInInfo.recaptchaToken;\n\n      Object.assign(newRequest, {\n        'phoneSignInInfo': {\n          recaptchaToken,\n          captchaResponse,\n          'clientType': RecaptchaClientType.WEB,\n          'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n        }\n      });\n    }\n    return newRequest;\n  }\n\n  if (!isCaptchaResp) {\n    Object.assign(newRequest, { captchaResponse });\n  } else {\n    Object.assign(newRequest, { 'captchaResp': captchaResponse });\n  }\n  Object.assign(newRequest, { 'clientType': RecaptchaClientType.WEB });\n  Object.assign(newRequest, {\n    'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n  });\n  return newRequest;\n}\n\ntype ActionMethod<TRequest, TResponse> = (\n  auth: AuthInternal,\n  request: TRequest\n) => Promise<TResponse>;\n\nexport async function handleRecaptchaFlow<TRequest extends object, TResponse>(\n  authInstance: AuthInternal,\n  request: TRequest,\n  actionName: RecaptchaActionName,\n  actionMethod: ActionMethod<TRequest, TResponse>,\n  recaptchaAuthProvider: RecaptchaAuthProvider\n): Promise<TResponse> {\n  if (recaptchaAuthProvider === RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER) {\n    if (\n      authInstance\n        ._getRecaptchaConfig()\n        ?.isProviderEnabled(RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER)\n    ) {\n      const requestWithRecaptcha = await injectRecaptchaFields(\n        authInstance,\n        request,\n        actionName,\n        actionName === RecaptchaActionName.GET_OOB_CODE\n      );\n      return actionMethod(authInstance, requestWithRecaptcha);\n    } else {\n      return actionMethod(authInstance, request).catch(async error => {\n        if (error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}`) {\n          console.log(\n            `${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`\n          );\n          const requestWithRecaptcha = await injectRecaptchaFields(\n            authInstance,\n            request,\n            actionName,\n            actionName === RecaptchaActionName.GET_OOB_CODE\n          );\n          return actionMethod(authInstance, requestWithRecaptcha);\n        } else {\n          return Promise.reject(error);\n        }\n      });\n    }\n  } else if (recaptchaAuthProvider === RecaptchaAuthProvider.PHONE_PROVIDER) {\n    if (\n      authInstance\n        ._getRecaptchaConfig()\n        ?.isProviderEnabled(RecaptchaAuthProvider.PHONE_PROVIDER)\n    ) {\n      const requestWithRecaptcha = await injectRecaptchaFields(\n        authInstance,\n        request,\n        actionName\n      );\n\n      return actionMethod(authInstance, requestWithRecaptcha).catch(\n        async error => {\n          if (\n            authInstance\n              ._getRecaptchaConfig()\n              ?.getProviderEnforcementState(\n                RecaptchaAuthProvider.PHONE_PROVIDER\n              ) === EnforcementState.AUDIT\n          ) {\n            // AUDIT mode\n            if (\n              error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}` ||\n              error.code === `auth/${AuthErrorCode.INVALID_APP_CREDENTIAL}`\n            ) {\n              console.log(\n                `Failed to verify with reCAPTCHA Enterprise. Automatically triggering the reCAPTCHA v2 flow to complete the ${actionName} flow.`\n              );\n              // reCAPTCHA Enterprise token is missing or reCAPTCHA Enterprise token\n              // check fails.\n              // Fallback to reCAPTCHA v2 flow.\n              const requestWithRecaptchaFields = await injectRecaptchaFields(\n                authInstance,\n                request,\n                actionName,\n                false, // isCaptchaResp\n                true // isFakeToken\n              );\n              // This will call the PhoneApiCaller to fetch and inject reCAPTCHA v2 token.\n              return actionMethod(authInstance, requestWithRecaptchaFields);\n            }\n          }\n          // ENFORCE mode or AUDIT mode with any other error.\n          return Promise.reject(error);\n        }\n      );\n    } else {\n      // Do reCAPTCHA v2 flow.\n      const requestWithRecaptchaFields = await injectRecaptchaFields(\n        authInstance,\n        request,\n        actionName,\n        false, // isCaptchaResp\n        true // isFakeToken\n      );\n\n      // This will call the PhoneApiCaller to fetch and inject v2 token.\n      return actionMethod(authInstance, requestWithRecaptchaFields);\n    }\n  } else {\n    return Promise.reject(\n      recaptchaAuthProvider + ' provider is not supported.'\n    );\n  }\n}\n\nexport async function _initializeRecaptchaConfig(auth: Auth): Promise<void> {\n  const authInternal = _castAuth(auth);\n\n  const response = await getRecaptchaConfig(authInternal, {\n    clientType: RecaptchaClientType.WEB,\n    version: RecaptchaVersion.ENTERPRISE\n  });\n\n  const config = new RecaptchaConfig(response);\n  if (authInternal.tenantId == null) {\n    authInternal._agentRecaptchaConfig = config;\n  } else {\n    authInternal._tenantRecaptchaConfigs[authInternal.tenantId] = config;\n  }\n\n  if (config.isAnyProviderEnabled()) {\n    const verifier = new RecaptchaEnterpriseVerifier(authInternal);\n    void verifier.verify();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _getProvider, FirebaseApp } from '@firebase/app';\nimport { deepEqual } from '@firebase/util';\nimport { Auth, Dependencies } from '../../model/public_types';\n\nimport { AuthErrorCode } from '../errors';\nimport { PersistenceInternal } from '../persistence';\nimport { _fail } from '../util/assert';\nimport { _getInstance } from '../util/instantiator';\nimport { AuthImpl } from './auth_impl';\n\n/**\n * Initializes an {@link Auth} instance with fine-grained control over\n * {@link Dependencies}.\n *\n * @remarks\n *\n * This function allows more control over the {@link Auth} instance than\n * {@link getAuth}. `getAuth` uses platform-specific defaults to supply\n * the {@link Dependencies}. In general, `getAuth` is the easiest way to\n * initialize Auth and works for most use cases. Use `initializeAuth` if you\n * need control over which persistence layer is used, or to minimize bundle\n * size if you're not using either `signInWithPopup` or `signInWithRedirect`.\n *\n * For example, if your app only uses anonymous accounts and you only want\n * accounts saved for the current session, initialize `Auth` with:\n *\n * ```js\n * const auth = initializeAuth(app, {\n *   persistence: browserSessionPersistence,\n *   popupRedirectResolver: undefined,\n * });\n * ```\n *\n * @public\n */\nexport function initializeAuth(app: FirebaseApp, deps?: Dependencies): Auth {\n  const provider = _getProvider(app, 'auth');\n\n  if (provider.isInitialized()) {\n    const auth = provider.getImmediate() as AuthImpl;\n    const initialOptions = provider.getOptions() as Dependencies;\n    if (deepEqual(initialOptions, deps ?? {})) {\n      return auth;\n    } else {\n      _fail(auth, AuthErrorCode.ALREADY_INITIALIZED);\n    }\n  }\n\n  const auth = provider.initialize({ options: deps }) as AuthImpl;\n\n  return auth;\n}\n\nexport function _initializeAuthInstance(\n  auth: AuthImpl,\n  deps?: Dependencies\n): void {\n  const persistence = deps?.persistence || [];\n  const hierarchy = (\n    Array.isArray(persistence) ? persistence : [persistence]\n  ).map<PersistenceInternal>(_getInstance);\n  if (deps?.errorMap) {\n    auth._updateErrorMap(deps.errorMap);\n  }\n\n  // This promise is intended to float; auth initialization happens in the\n  // background, meanwhile the auth object may be used by the app.\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  auth._initializeWithPersistence(hierarchy, deps?.popupRedirectResolver);\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Auth } from '../../model/public_types';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _castAuth } from './auth_impl';\nimport {\n  deepEqual,\n  isCloudWorkstation,\n  pingServer,\n  updateEmulatorBanner\n} from '@firebase/util';\n\n/**\n * Changes the {@link Auth} instance to communicate with the Firebase Auth Emulator, instead of production\n * Firebase Auth services.\n *\n * @remarks\n * This must be called synchronously immediately following the first call to\n * {@link initializeAuth}.  Do not use with production credentials as emulator\n * traffic is not encrypted.\n *\n *\n * @example\n * ```javascript\n * connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param url - The URL at which the emulator is running (eg, 'http://localhost:9099').\n * @param options - Optional. `options.disableWarnings` defaults to `false`. Set it to\n * `true` to disable the warning banner attached to the DOM.\n *\n * @public\n */\nexport function connectAuthEmulator(\n  auth: Auth,\n  url: string,\n  options?: { disableWarnings: boolean }\n): void {\n  const authInternal = _castAuth(auth);\n  _assert(\n    /^https?:\\/\\//.test(url),\n    authInternal,\n    AuthErrorCode.INVALID_EMULATOR_SCHEME\n  );\n\n  const disableWarnings = !!options?.disableWarnings;\n\n  const protocol = extractProtocol(url);\n  const { host, port } = extractHostAndPort(url);\n  const portStr = port === null ? '' : `:${port}`;\n\n  // Always replace path with \"/\" (even if input url had no path at all, or had a different one).\n  const emulator = { url: `${protocol}//${host}${portStr}/` };\n  const emulatorConfig = Object.freeze({\n    host,\n    port,\n    protocol: protocol.replace(':', ''),\n    options: Object.freeze({ disableWarnings })\n  });\n\n  // There are a few scenarios to guard against if the Auth instance has already started:\n  if (!authInternal._canInitEmulator) {\n    // Applications may not initialize the emulator for the first time if Auth has already started\n    // to make network requests.\n    _assert(\n      authInternal.config.emulator && authInternal.emulatorConfig,\n      authInternal,\n      AuthErrorCode.EMULATOR_CONFIG_FAILED\n    );\n\n    // Applications may not alter the configuration of the emulator (aka pass a different config)\n    // once Auth has started to make network requests.\n    _assert(\n      deepEqual(emulator, authInternal.config.emulator) &&\n        deepEqual(emulatorConfig, authInternal.emulatorConfig),\n      authInternal,\n      AuthErrorCode.EMULATOR_CONFIG_FAILED\n    );\n\n    // It's valid, however, to invoke connectAuthEmulator() after Auth has started making\n    // connections, so long as the config matches the existing config. This results in a no-op.\n    return;\n  }\n\n  authInternal.config.emulator = emulator;\n  authInternal.emulatorConfig = emulatorConfig;\n  authInternal.settings.appVerificationDisabledForTesting = true;\n\n  // Workaround to get cookies in Firebase Studio\n  if (isCloudWorkstation(host)) {\n    void pingServer(`${protocol}//${host}${portStr}`);\n    updateEmulatorBanner('Auth', true);\n  } else if (!disableWarnings) {\n    emitEmulatorWarning();\n  }\n}\n\nfunction extractProtocol(url: string): string {\n  const protocolEnd = url.indexOf(':');\n  return protocolEnd < 0 ? '' : url.substr(0, protocolEnd + 1);\n}\n\nfunction extractHostAndPort(url: string): {\n  host: string;\n  port: number | null;\n} {\n  const protocol = extractProtocol(url);\n  const authority = /(\\/\\/)?([^?#/]+)/.exec(url.substr(protocol.length)); // Between // and /, ? or #.\n  if (!authority) {\n    return { host: '', port: null };\n  }\n  const hostAndPort = authority[2].split('@').pop() || ''; // Strip out \"username:password@\".\n  const bracketedIPv6 = /^(\\[[^\\]]+\\])(:|$)/.exec(hostAndPort);\n  if (bracketedIPv6) {\n    const host = bracketedIPv6[1];\n    return { host, port: parsePort(hostAndPort.substr(host.length + 1)) };\n  } else {\n    const [host, port] = hostAndPort.split(':');\n    return { host, port: parsePort(port) };\n  }\n}\n\nfunction parsePort(portStr: string): number | null {\n  if (!portStr) {\n    return null;\n  }\n  const port = Number(portStr);\n  if (isNaN(port)) {\n    return null;\n  }\n  return port;\n}\n\nfunction emitEmulatorWarning(): void {\n  function attachBanner(): void {\n    const el = document.createElement('p');\n    const sty = el.style;\n    el.innerText =\n      'Running in emulator mode. Do not use with production credentials.';\n    sty.position = 'fixed';\n    sty.width = '100%';\n    sty.backgroundColor = '#ffffff';\n    sty.border = '.1em solid #000000';\n    sty.color = '#b50000';\n    sty.bottom = '0px';\n    sty.left = '0px';\n    sty.margin = '0px';\n    sty.zIndex = '10000';\n    sty.textAlign = 'center';\n    el.classList.add('firebase-emulator-warning');\n    document.body.appendChild(el);\n  }\n\n  if (typeof console !== 'undefined' && typeof console.info === 'function') {\n    console.info(\n      'WARNING: You are using the Auth Emulator,' +\n        ' which is intended for local testing only.  Do not use with' +\n        ' production credentials.'\n    );\n  }\n  if (typeof window !== 'undefined' && typeof document !== 'undefined') {\n    if (document.readyState === 'loading') {\n      window.addEventListener('DOMContentLoaded', attachBanner);\n    } else {\n      attachBanner();\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { debugFail } from '../util/assert';\n\n/**\n * Interface that represents the credentials returned by an {@link AuthProvider}.\n *\n * @remarks\n * Implementations specify the details about each auth provider's credential requirements.\n *\n * @public\n */\nexport class AuthCredential {\n  /** @internal */\n  protected constructor(\n    /**\n     * The authentication provider ID for the credential.\n     *\n     * @remarks\n     * For example, 'facebook.com', or 'google.com'.\n     */\n    readonly providerId: string,\n    /**\n     * The authentication sign in method for the credential.\n     *\n     * @remarks\n     * For example, {@link SignInMethod}.EMAIL_PASSWORD, or\n     * {@link SignInMethod}.EMAIL_LINK. This corresponds to the sign-in method\n     * identifier as returned in {@link fetchSignInMethodsForEmail}.\n     */\n    readonly signInMethod: string\n  ) {}\n\n  /**\n   * Returns a JSON-serializable representation of this object.\n   *\n   * @returns a JSON-serializable representation of this object.\n   */\n  toJSON(): object {\n    return debugFail('not implemented');\n  }\n\n  /** @internal */\n  _getIdTokenResponse(_auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return debugFail('not implemented');\n  }\n  /** @internal */\n  _linkToIdToken(\n    _auth: AuthInternal,\n    _idToken: string\n  ): Promise<IdTokenResponse> {\n    return debugFail('not implemented');\n  }\n  /** @internal */\n  _getReauthenticationResolver(_auth: AuthInternal): Promise<IdTokenResponse> {\n    return debugFail('not implemented');\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeOperation, Auth } from '../../model/public_types';\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { MfaEnrollment } from './mfa';\nimport { SignUpRequest, SignUpResponse } from '../authentication/sign_up';\n\nexport interface ResetPasswordRequest {\n  oobCode: string;\n  newPassword?: string;\n  tenantId?: string;\n}\n\nexport interface ResetPasswordResponse {\n  email: string;\n  newEmail?: string;\n  requestType?: ActionCodeOperation;\n  mfaInfo?: MfaEnrollment;\n}\n\nexport async function resetPassword(\n  auth: Auth,\n  request: ResetPasswordRequest\n): Promise<ResetPasswordResponse> {\n  return _performApiRequest<ResetPasswordRequest, ResetPasswordResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.RESET_PASSWORD,\n    _addTidIfNecessary(auth, request)\n  );\n}\nexport interface UpdateEmailPasswordRequest {\n  idToken: string;\n  returnSecureToken?: boolean;\n  email?: string;\n  password?: string;\n}\n\nexport interface UpdateEmailPasswordResponse extends IdTokenResponse {}\n\nexport async function updateEmailPassword(\n  auth: Auth,\n  request: UpdateEmailPasswordRequest\n): Promise<UpdateEmailPasswordResponse> {\n  return _performApiRequest<\n    UpdateEmailPasswordRequest,\n    UpdateEmailPasswordResponse\n  >(auth, HttpMethod.POST, Endpoint.SET_ACCOUNT_INFO, request);\n}\n\n// Used for linking an email/password account to an existing idToken. Uses the same request/response\n// format as updateEmailPassword.\nexport async function linkEmailPassword(\n  auth: Auth,\n  request: SignUpRequest\n): Promise<SignUpResponse> {\n  return _performApiRequest<SignUpRequest, SignUpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_UP,\n    request\n  );\n}\n\nexport interface ApplyActionCodeRequest {\n  oobCode: string;\n  tenantId?: string;\n}\n\nexport interface ApplyActionCodeResponse {}\n\nexport async function applyActionCode(\n  auth: Auth,\n  request: ApplyActionCodeRequest\n): Promise<ApplyActionCodeResponse> {\n  return _performApiRequest<ApplyActionCodeRequest, ApplyActionCodeResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SET_ACCOUNT_INFO,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeOperation, Auth } from '../../model/public_types';\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _performApiRequest,\n  _performSignInRequest\n} from '../index';\nimport { IdToken, IdTokenResponse } from '../../model/id_token';\n\nexport interface SignInWithPasswordRequest {\n  returnSecureToken?: boolean;\n  email: string;\n  password: string;\n  tenantId?: string;\n  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface SignInWithPasswordResponse extends IdTokenResponse {\n  email: string;\n  displayName: string;\n}\n\nexport async function signInWithPassword(\n  auth: Auth,\n  request: SignInWithPasswordRequest\n): Promise<SignInWithPasswordResponse> {\n  return _performSignInRequest<\n    SignInWithPasswordRequest,\n    SignInWithPasswordResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PASSWORD,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface GetOobCodeRequest {\n  email?: string; // Everything except VERIFY_AND_CHANGE_EMAIL\n  continueUrl?: string;\n  iOSBundleId?: string;\n  iosAppStoreId?: string;\n  androidPackageName?: string;\n  androidInstallApp?: boolean;\n  androidMinimumVersionCode?: string;\n  canHandleCodeInApp?: boolean;\n  dynamicLinkDomain?: string;\n  tenantId?: string;\n  targetProjectid?: string;\n  linkDomain?: string;\n}\n\nexport interface VerifyEmailRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.VERIFY_EMAIL;\n  idToken: IdToken;\n}\n\nexport interface PasswordResetRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.PASSWORD_RESET;\n  email: string;\n  captchaResp?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface EmailSignInRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.EMAIL_SIGNIN;\n  email: string;\n  captchaResp?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface VerifyAndChangeEmailRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;\n  idToken: IdToken;\n  newEmail: string;\n}\n\ninterface GetOobCodeResponse {\n  email: string;\n}\n\nexport interface VerifyEmailResponse extends GetOobCodeResponse {}\nexport interface PasswordResetResponse extends GetOobCodeResponse {}\nexport interface EmailSignInResponse extends GetOobCodeResponse {}\nexport interface VerifyAndChangeEmailResponse extends GetOobCodeRequest {}\n\nasync function sendOobCode(\n  auth: Auth,\n  request: GetOobCodeRequest\n): Promise<GetOobCodeResponse> {\n  return _performApiRequest<GetOobCodeRequest, GetOobCodeResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SEND_OOB_CODE,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport async function sendEmailVerification(\n  auth: Auth,\n  request: VerifyEmailRequest\n): Promise<VerifyEmailResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function sendPasswordResetEmail(\n  auth: Auth,\n  request: PasswordResetRequest\n): Promise<PasswordResetResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function sendSignInLinkToEmail(\n  auth: Auth,\n  request: EmailSignInRequest\n): Promise<EmailSignInResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function verifyAndChangeEmail(\n  auth: Auth,\n  request: VerifyAndChangeEmailRequest\n): Promise<VerifyAndChangeEmailResponse> {\n  return sendOobCode(auth, request);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performSignInRequest,\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithEmailLinkRequest {\n  email: string;\n  oobCode: string;\n  tenantId?: string;\n}\n\nexport interface SignInWithEmailLinkResponse extends IdTokenResponse {\n  email: string;\n  isNewUser: boolean;\n}\n\nexport async function signInWithEmailLink(\n  auth: Auth,\n  request: SignInWithEmailLinkRequest\n): Promise<SignInWithEmailLinkResponse> {\n  return _performSignInRequest<\n    SignInWithEmailLinkRequest,\n    SignInWithEmailLinkResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface SignInWithEmailLinkForLinkingRequest\n  extends SignInWithEmailLinkRequest {\n  idToken: string;\n}\n\nexport async function signInWithEmailLinkForLinking(\n  auth: Auth,\n  request: SignInWithEmailLinkForLinkingRequest\n): Promise<SignInWithEmailLinkResponse> {\n  return _performSignInRequest<\n    SignInWithEmailLinkForLinkingRequest,\n    SignInWithEmailLinkResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { linkEmailPassword } from '../../api/account_management/email_and_password';\nimport {\n  signInWithPassword,\n  SignInWithPasswordRequest\n} from '../../api/authentication/email_and_password';\nimport {\n  signInWithEmailLink,\n  signInWithEmailLinkForLinking\n} from '../../api/authentication/email_link';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from '../util/assert';\nimport { AuthCredential } from './auth_credential';\nimport { handleRecaptchaFlow } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport {\n  RecaptchaActionName,\n  RecaptchaClientType,\n  RecaptchaAuthProvider\n} from '../../api';\nimport { SignUpRequest } from '../../api/authentication/sign_up';\n/**\n * Interface that represents the credentials returned by {@link EmailAuthProvider} for\n * {@link ProviderId}.PASSWORD\n *\n * @remarks\n * Covers both {@link SignInMethod}.EMAIL_PASSWORD and\n * {@link SignInMethod}.EMAIL_LINK.\n *\n * @public\n */\nexport class EmailAuthCredential extends AuthCredential {\n  /** @internal */\n  private constructor(\n    /** @internal */\n    readonly _email: string,\n    /** @internal */\n    readonly _password: string,\n    signInMethod: SignInMethod,\n    /** @internal */\n    readonly _tenantId: string | null = null\n  ) {\n    super(ProviderId.PASSWORD, signInMethod);\n  }\n\n  /** @internal */\n  static _fromEmailAndPassword(\n    email: string,\n    password: string\n  ): EmailAuthCredential {\n    return new EmailAuthCredential(\n      email,\n      password,\n      SignInMethod.EMAIL_PASSWORD\n    );\n  }\n\n  /** @internal */\n  static _fromEmailAndCode(\n    email: string,\n    oobCode: string,\n    tenantId: string | null = null\n  ): EmailAuthCredential {\n    return new EmailAuthCredential(\n      email,\n      oobCode,\n      SignInMethod.EMAIL_LINK,\n      tenantId\n    );\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON} */\n  toJSON(): object {\n    return {\n      email: this._email,\n      password: this._password,\n      signInMethod: this.signInMethod,\n      tenantId: this._tenantId\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an {@link  AuthCredential}.\n   *\n   * @param json - Either `object` or the stringified representation of the object. When string is\n   * provided, `JSON.parse` would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link AuthCredential}, null is returned.\n   */\n  static fromJSON(json: object | string): EmailAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    if (obj?.email && obj?.password) {\n      if (obj.signInMethod === SignInMethod.EMAIL_PASSWORD) {\n        return this._fromEmailAndPassword(obj.email, obj.password);\n      } else if (obj.signInMethod === SignInMethod.EMAIL_LINK) {\n        return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);\n      }\n    }\n    return null;\n  }\n\n  /** @internal */\n  async _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    switch (this.signInMethod) {\n      case SignInMethod.EMAIL_PASSWORD:\n        const request: SignInWithPasswordRequest = {\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password,\n          clientType: RecaptchaClientType.WEB\n        };\n        return handleRecaptchaFlow(\n          auth,\n          request,\n          RecaptchaActionName.SIGN_IN_WITH_PASSWORD,\n          signInWithPassword,\n          RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n        );\n      case SignInMethod.EMAIL_LINK:\n        return signInWithEmailLink(auth, {\n          email: this._email,\n          oobCode: this._password\n        });\n      default:\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  /** @internal */\n  async _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    switch (this.signInMethod) {\n      case SignInMethod.EMAIL_PASSWORD:\n        const request: SignUpRequest = {\n          idToken,\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password,\n          clientType: RecaptchaClientType.WEB\n        };\n        return handleRecaptchaFlow(\n          auth,\n          request,\n          RecaptchaActionName.SIGN_UP_PASSWORD,\n          linkEmailPassword,\n          RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n        );\n      case SignInMethod.EMAIL_LINK:\n        return signInWithEmailLinkForLinking(auth, {\n          idToken,\n          email: this._email,\n          oobCode: this._password\n        });\n      default:\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return this._getIdTokenResponse(auth);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdToken, IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithIdpRequest {\n  requestUri: string;\n  postBody?: string;\n  sessionId?: string;\n  tenantId?: string;\n  returnSecureToken: boolean;\n  returnIdpCredential?: boolean;\n  idToken?: IdToken;\n  autoCreate?: boolean;\n  pendingToken?: string;\n}\n\n/**\n * @internal\n */\nexport interface SignInWithIdpResponse extends IdTokenResponse {\n  oauthAccessToken?: string;\n  oauthTokenSecret?: string;\n  nonce?: string;\n  oauthIdToken?: string;\n  pendingToken?: string;\n}\n\nexport async function signInWithIdp(\n  auth: Auth,\n  request: SignInWithIdpRequest\n): Promise<SignInWithIdpResponse> {\n  return _performSignInRequest<SignInWithIdpRequest, SignInWithIdpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_IDP,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { querystring } from '@firebase/util';\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from '../util/assert';\nimport { AuthCredential } from './auth_credential';\n\nconst IDP_REQUEST_URI = 'http://localhost';\n\nexport interface OAuthCredentialParams {\n  // OAuth 2 uses either id token or access token\n  idToken?: string | null;\n  accessToken?: string | null;\n\n  // These fields are used with OAuth 1\n  oauthToken?: string;\n  secret?: string;\n  oauthTokenSecret?: string;\n\n  // Nonce is only set if pendingToken is not present\n  nonce?: string;\n  pendingToken?: string;\n\n  // Utilities\n  providerId: string;\n  signInMethod: string;\n}\n\n/**\n * Represents the OAuth credentials returned by an {@link OAuthProvider}.\n *\n * @remarks\n * Implementations specify the details about each auth provider's credential requirements.\n *\n * @public\n */\nexport class OAuthCredential extends AuthCredential {\n  /**\n   * The OAuth ID token associated with the credential if it belongs to an OIDC provider,\n   * such as `google.com`.\n   * @readonly\n   */\n  idToken?: string;\n  /**\n   * The OAuth access token associated with the credential if it belongs to an\n   * {@link OAuthProvider}, such as `facebook.com`, `twitter.com`, etc.\n   * @readonly\n   */\n  accessToken?: string;\n  /**\n   * The OAuth access token secret associated with the credential if it belongs to an OAuth 1.0\n   * provider, such as `twitter.com`.\n   * @readonly\n   */\n  secret?: string;\n\n  private nonce?: string;\n  private pendingToken: string | null = null;\n\n  /** @internal */\n  static _fromParams(params: OAuthCredentialParams): OAuthCredential {\n    const cred = new OAuthCredential(params.providerId, params.signInMethod);\n\n    if (params.idToken || params.accessToken) {\n      // OAuth 2 and either ID token or access token.\n      if (params.idToken) {\n        cred.idToken = params.idToken;\n      }\n\n      if (params.accessToken) {\n        cred.accessToken = params.accessToken;\n      }\n\n      // Add nonce if available and no pendingToken is present.\n      if (params.nonce && !params.pendingToken) {\n        cred.nonce = params.nonce;\n      }\n\n      if (params.pendingToken) {\n        cred.pendingToken = params.pendingToken;\n      }\n    } else if (params.oauthToken && params.oauthTokenSecret) {\n      // OAuth 1 and OAuth token with token secret\n      cred.accessToken = params.oauthToken;\n      cred.secret = params.oauthTokenSecret;\n    } else {\n      _fail(AuthErrorCode.ARGUMENT_ERROR);\n    }\n\n    return cred;\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON}  */\n  toJSON(): object {\n    return {\n      idToken: this.idToken,\n      accessToken: this.accessToken,\n      secret: this.secret,\n      nonce: this.nonce,\n      pendingToken: this.pendingToken,\n      providerId: this.providerId,\n      signInMethod: this.signInMethod\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an\n   * {@link  AuthCredential}.\n   *\n   * @param json - Input can be either Object or the stringified representation of the object.\n   * When string is provided, JSON.parse would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.\n   */\n  static fromJSON(json: string | object): OAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    const { providerId, signInMethod, ...rest }: OAuthCredentialParams = obj;\n    if (!providerId || !signInMethod) {\n      return null;\n    }\n\n    const cred = new OAuthCredential(providerId, signInMethod);\n    cred.idToken = rest.idToken || undefined;\n    cred.accessToken = rest.accessToken || undefined;\n    cred.secret = rest.secret;\n    cred.nonce = rest.nonce;\n    cred.pendingToken = rest.pendingToken || null;\n    return cred;\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.idToken = idToken;\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.autoCreate = false;\n    return signInWithIdp(auth, request);\n  }\n\n  private buildRequest(): SignInWithIdpRequest {\n    const request: SignInWithIdpRequest = {\n      requestUri: IDP_REQUEST_URI,\n      returnSecureToken: true\n    };\n\n    if (this.pendingToken) {\n      request.pendingToken = this.pendingToken;\n    } else {\n      const postBody: Record<string, string> = {};\n      if (this.idToken) {\n        postBody['id_token'] = this.idToken;\n      }\n      if (this.accessToken) {\n        postBody['access_token'] = this.accessToken;\n      }\n      if (this.secret) {\n        postBody['oauth_token_secret'] = this.secret;\n      }\n\n      postBody['providerId'] = this.providerId;\n      if (this.nonce && !this.pendingToken) {\n        postBody['nonce'] = this.nonce;\n      }\n\n      request.postBody = querystring(postBody);\n    }\n\n    return request;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _makeTaggedError,\n  _performApiRequest,\n  _performSignInRequest\n} from '../index';\nimport { AuthErrorCode } from '../../core/errors';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { ServerError, ServerErrorMap } from '../errors';\nimport { Auth } from '../../model/public_types';\n\nexport interface SendPhoneVerificationCodeRequest {\n  phoneNumber: string;\n  // reCAPTCHA v2 token\n  recaptchaToken?: string;\n  tenantId?: string;\n  // reCAPTCHA Enterprise token\n  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface SendPhoneVerificationCodeResponse {\n  sessionInfo: string;\n}\n\nexport async function sendPhoneVerificationCode(\n  auth: Auth,\n  request: SendPhoneVerificationCodeRequest\n): Promise<SendPhoneVerificationCodeResponse> {\n  return _performApiRequest<\n    SendPhoneVerificationCodeRequest,\n    SendPhoneVerificationCodeResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SEND_VERIFICATION_CODE,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\n/**\n * @internal\n */\nexport interface SignInWithPhoneNumberRequest {\n  temporaryProof?: string;\n  phoneNumber?: string;\n  sessionInfo?: string;\n  code?: string;\n  tenantId?: string;\n}\n\nexport interface LinkWithPhoneNumberRequest\n  extends SignInWithPhoneNumberRequest {\n  idToken: string;\n}\n\n/**\n * @internal\n */\nexport interface SignInWithPhoneNumberResponse extends IdTokenResponse {\n  temporaryProof?: string;\n  phoneNumber?: string;\n}\n\nexport async function signInWithPhoneNumber(\n  auth: Auth,\n  request: SignInWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  return _performSignInRequest<\n    SignInWithPhoneNumberRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport async function linkWithPhoneNumber(\n  auth: Auth,\n  request: LinkWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  const response = await _performSignInRequest<\n    LinkWithPhoneNumberRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, request)\n  );\n  if (response.temporaryProof) {\n    throw _makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, response);\n  }\n  return response;\n}\n\ninterface VerifyPhoneNumberForExistingRequest\n  extends SignInWithPhoneNumberRequest {\n  operation: 'REAUTH';\n}\n\nconst VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_: Partial<\n  ServerErrorMap<ServerError>\n> = {\n  [ServerError.USER_NOT_FOUND]: AuthErrorCode.USER_DELETED\n};\n\nexport async function verifyPhoneNumberForExisting(\n  auth: Auth,\n  request: SignInWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  const apiRequest: VerifyPhoneNumberForExistingRequest = {\n    ...request,\n    operation: 'REAUTH'\n  };\n  return _performSignInRequest<\n    VerifyPhoneNumberForExistingRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, apiRequest),\n    VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport {\n  linkWithPhoneNumber,\n  signInWithPhoneNumber,\n  SignInWithPhoneNumberRequest,\n  verifyPhoneNumberForExisting\n} from '../../api/authentication/sms';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthCredential } from './auth_credential';\n\nexport interface PhoneAuthCredentialParameters {\n  verificationId?: string;\n  verificationCode?: string;\n  phoneNumber?: string;\n  temporaryProof?: string;\n}\n\n/**\n * Represents the credentials returned by {@link PhoneAuthProvider}.\n *\n * @public\n */\nexport class PhoneAuthCredential extends AuthCredential {\n  private constructor(private readonly params: PhoneAuthCredentialParameters) {\n    super(ProviderId.PHONE, SignInMethod.PHONE);\n  }\n\n  /** @internal */\n  static _fromVerification(\n    verificationId: string,\n    verificationCode: string\n  ): PhoneAuthCredential {\n    return new PhoneAuthCredential({ verificationId, verificationCode });\n  }\n\n  /** @internal */\n  static _fromTokenResponse(\n    phoneNumber: string,\n    temporaryProof: string\n  ): PhoneAuthCredential {\n    return new PhoneAuthCredential({ phoneNumber, temporaryProof });\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return signInWithPhoneNumber(auth, this._makeVerificationRequest());\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    return linkWithPhoneNumber(auth, {\n      idToken,\n      ...this._makeVerificationRequest()\n    });\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return verifyPhoneNumberForExisting(auth, this._makeVerificationRequest());\n  }\n\n  /** @internal */\n  _makeVerificationRequest(): SignInWithPhoneNumberRequest {\n    const { temporaryProof, phoneNumber, verificationId, verificationCode } =\n      this.params;\n    if (temporaryProof && phoneNumber) {\n      return { temporaryProof, phoneNumber };\n    }\n\n    return {\n      sessionInfo: verificationId,\n      code: verificationCode\n    };\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON} */\n  toJSON(): object {\n    const obj: Record<string, string> = {\n      providerId: this.providerId\n    };\n    if (this.params.phoneNumber) {\n      obj.phoneNumber = this.params.phoneNumber;\n    }\n    if (this.params.temporaryProof) {\n      obj.temporaryProof = this.params.temporaryProof;\n    }\n    if (this.params.verificationCode) {\n      obj.verificationCode = this.params.verificationCode;\n    }\n    if (this.params.verificationId) {\n      obj.verificationId = this.params.verificationId;\n    }\n\n    return obj;\n  }\n\n  /** Generates a phone credential based on a plain object or a JSON string. */\n  static fromJSON(json: object | string): PhoneAuthCredential | null {\n    if (typeof json === 'string') {\n      json = JSON.parse(json);\n    }\n\n    const { verificationId, verificationCode, phoneNumber, temporaryProof } =\n      json as { [key: string]: string };\n    if (\n      !verificationCode &&\n      !verificationId &&\n      !phoneNumber &&\n      !temporaryProof\n    ) {\n      return null;\n    }\n\n    return new PhoneAuthCredential({\n      verificationId,\n      verificationCode,\n      phoneNumber,\n      temporaryProof\n    });\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { extractQuerystring, querystringDecode } from '@firebase/util';\nimport { ActionCodeOperation } from '../model/public_types';\nimport { AuthErrorCode } from './errors';\nimport { _assert } from './util/assert';\n\n/**\n * Enums for fields in URL query string.\n *\n * @enum {string}\n */\nconst enum QueryField {\n  API_KEY = 'apiKey',\n  CODE = 'oobCode',\n  CONTINUE_URL = 'continueUrl',\n  LANGUAGE_CODE = 'lang',\n  MODE = 'mode',\n  TENANT_ID = 'tenantId'\n}\n\n/**\n * Maps the mode string in action code URL to Action Code Info operation.\n *\n * @param mode\n */\nfunction parseMode(mode: string | null): ActionCodeOperation | null {\n  switch (mode) {\n    case 'recoverEmail':\n      return ActionCodeOperation.RECOVER_EMAIL;\n    case 'resetPassword':\n      return ActionCodeOperation.PASSWORD_RESET;\n    case 'signIn':\n      return ActionCodeOperation.EMAIL_SIGNIN;\n    case 'verifyEmail':\n      return ActionCodeOperation.VERIFY_EMAIL;\n    case 'verifyAndChangeEmail':\n      return ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;\n    case 'revertSecondFactorAddition':\n      return ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION;\n    default:\n      return null;\n  }\n}\n\n/**\n * Helper to parse FDL links\n *\n * @param url\n */\nfunction parseDeepLink(url: string): string {\n  const link = querystringDecode(extractQuerystring(url))['link'];\n\n  // Double link case (automatic redirect).\n  const doubleDeepLink = link\n    ? querystringDecode(extractQuerystring(link))['deep_link_id']\n    : null;\n  // iOS custom scheme links.\n  const iOSDeepLink = querystringDecode(extractQuerystring(url))[\n    'deep_link_id'\n  ];\n  const iOSDoubleDeepLink = iOSDeepLink\n    ? querystringDecode(extractQuerystring(iOSDeepLink))['link']\n    : null;\n  return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;\n}\n\n/**\n * A utility class to parse email action URLs such as password reset, email verification,\n * email link sign in, etc.\n *\n * @public\n */\nexport class ActionCodeURL {\n  /**\n   * The API key of the email action link.\n   */\n  readonly apiKey: string;\n  /**\n   * The action code of the email action link.\n   */\n  readonly code: string;\n  /**\n   * The continue URL of the email action link. Null if not provided.\n   */\n  readonly continueUrl: string | null;\n  /**\n   * The language code of the email action link. Null if not provided.\n   */\n  readonly languageCode: string | null;\n  /**\n   * The action performed by the email action link. It returns from one of the types from\n   * {@link ActionCodeInfo}\n   */\n  readonly operation: string;\n  /**\n   * The tenant ID of the email action link. Null if the email action is from the parent project.\n   */\n  readonly tenantId: string | null;\n\n  /**\n   * @param actionLink - The link from which to extract the URL.\n   * @returns The {@link ActionCodeURL} object, or null if the link is invalid.\n   *\n   * @internal\n   */\n  constructor(actionLink: string) {\n    const searchParams = querystringDecode(extractQuerystring(actionLink));\n    const apiKey = searchParams[QueryField.API_KEY] ?? null;\n    const code = searchParams[QueryField.CODE] ?? null;\n    const operation = parseMode(searchParams[QueryField.MODE] ?? null);\n    // Validate API key, code and mode.\n    _assert(apiKey && code && operation, AuthErrorCode.ARGUMENT_ERROR);\n    this.apiKey = apiKey;\n    this.operation = operation;\n    this.code = code;\n    this.continueUrl = searchParams[QueryField.CONTINUE_URL] ?? null;\n    this.languageCode = searchParams[QueryField.LANGUAGE_CODE] ?? null;\n    this.tenantId = searchParams[QueryField.TENANT_ID] ?? null;\n  }\n\n  /**\n   * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,\n   * otherwise returns null.\n   *\n   * @param link  - The email action link string.\n   * @returns The {@link ActionCodeURL} object, or null if the link is invalid.\n   *\n   * @public\n   */\n  static parseLink(link: string): ActionCodeURL | null {\n    const actionLink = parseDeepLink(link);\n    try {\n      return new ActionCodeURL(actionLink);\n    } catch {\n      return null;\n    }\n  }\n}\n\n/**\n * Parses the email action link string and returns an {@link ActionCodeURL} if\n * the link is valid, otherwise returns null.\n *\n * @public\n */\nexport function parseActionCodeURL(link: string): ActionCodeURL | null {\n  return ActionCodeURL.parseLink(link);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\nimport { AuthProvider } from '../../model/public_types';\n\nimport { ActionCodeURL } from '../action_code_url';\nimport { EmailAuthCredential } from '../credentials/email';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\n\n/**\n * Provider for generating {@link EmailAuthCredential}.\n *\n * @public\n */\nexport class EmailAuthProvider implements AuthProvider {\n  /**\n   * Always set to {@link ProviderId}.PASSWORD, even for email link.\n   */\n  static readonly PROVIDER_ID: 'password' = ProviderId.PASSWORD;\n  /**\n   * Always set to {@link SignInMethod}.EMAIL_PASSWORD.\n   */\n  static readonly EMAIL_PASSWORD_SIGN_IN_METHOD: 'password' =\n    SignInMethod.EMAIL_PASSWORD;\n  /**\n   * Always set to {@link SignInMethod}.EMAIL_LINK.\n   */\n  static readonly EMAIL_LINK_SIGN_IN_METHOD: 'emailLink' =\n    SignInMethod.EMAIL_LINK;\n  /**\n   * Always set to {@link ProviderId}.PASSWORD, even for email link.\n   */\n  readonly providerId = EmailAuthProvider.PROVIDER_ID;\n\n  /**\n   * Initialize an {@link AuthCredential} using an email and password.\n   *\n   * @example\n   * ```javascript\n   * const authCredential = EmailAuthProvider.credential(email, password);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * ```javascript\n   * const userCredential = await signInWithEmailAndPassword(auth, email, password);\n   * ```\n   *\n   * @param email - Email address.\n   * @param password - User account password.\n   * @returns The auth provider credential.\n   */\n  static credential(email: string, password: string): EmailAuthCredential {\n    return EmailAuthCredential._fromEmailAndPassword(email, password);\n  }\n\n  /**\n   * Initialize an {@link AuthCredential} using an email and an email link after a sign in with\n   * email link operation.\n   *\n   * @example\n   * ```javascript\n   * const authCredential = EmailAuthProvider.credentialWithLink(auth, email, emailLink);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * ```javascript\n   * await sendSignInLinkToEmail(auth, email);\n   * // Obtain emailLink from user.\n   * const userCredential = await signInWithEmailLink(auth, email, emailLink);\n   * ```\n   *\n   * @param auth - The {@link Auth} instance used to verify the link.\n   * @param email - Email address.\n   * @param emailLink - Sign-in email link.\n   * @returns - The auth provider credential.\n   */\n  static credentialWithLink(\n    email: string,\n    emailLink: string\n  ): EmailAuthCredential {\n    const actionCodeUrl = ActionCodeURL.parseLink(emailLink);\n    _assert(actionCodeUrl, AuthErrorCode.ARGUMENT_ERROR);\n\n    return EmailAuthCredential._fromEmailAndCode(\n      email,\n      actionCodeUrl.code,\n      actionCodeUrl.tenantId\n    );\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider } from '../../model/public_types';\n\n/**\n * Map of OAuth Custom Parameters.\n *\n * @public\n */\nexport type CustomParameters = Record<string, string>;\n\n/**\n * The base class for all Federated providers (OAuth (including OIDC), SAML).\n *\n * This class is not meant to be instantiated directly.\n *\n * @public\n */\nexport abstract class FederatedAuthProvider implements AuthProvider {\n  /** @internal */\n  defaultLanguageCode: string | null = null;\n  /** @internal */\n  private customParameters: CustomParameters = {};\n\n  /**\n   * Constructor for generic OAuth providers.\n   *\n   * @param providerId - Provider for which credentials should be generated.\n   */\n  constructor(readonly providerId: string) {}\n\n  /**\n   * Set the language gode.\n   *\n   * @param languageCode - language code\n   */\n  setDefaultLanguage(languageCode: string | null): void {\n    this.defaultLanguageCode = languageCode;\n  }\n\n  /**\n   * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in\n   * operations.\n   *\n   * @remarks\n   * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,\n   * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.\n   *\n   * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.\n   */\n  setCustomParameters(customOAuthParameters: CustomParameters): AuthProvider {\n    this.customParameters = customOAuthParameters;\n    return this;\n  }\n\n  /**\n   * Retrieve the current list of {@link CustomParameters}.\n   */\n  getCustomParameters(): CustomParameters {\n    return this.customParameters;\n  }\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider, UserCredential } from '../../model/public_types';\n\nimport { _assert } from '../util/assert';\nimport { AuthErrorCode } from '../errors';\n\nimport { OAuthCredential, OAuthCredentialParams } from '../credentials/oauth';\nimport { UserCredentialInternal } from '../../model/user';\nimport { FirebaseError } from '@firebase/util';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { SignInWithIdpResponse } from '../../../internal';\nimport { FederatedAuthProvider } from './federated';\n\n/**\n * Defines the options for initializing an {@link OAuthCredential}.\n *\n * @remarks\n * For ID tokens with nonce claim, the raw nonce has to also be provided.\n *\n * @public\n */\nexport interface OAuthCredentialOptions {\n  /**\n   * The OAuth ID token used to initialize the {@link OAuthCredential}.\n   */\n  idToken?: string;\n  /**\n   * The OAuth access token used to initialize the {@link OAuthCredential}.\n   */\n  accessToken?: string;\n  /**\n   * The raw nonce associated with the ID token.\n   *\n   * @remarks\n   * It is required when an ID token with a nonce field is provided. The SHA-256 hash of the\n   * raw nonce must match the nonce field in the ID token.\n   */\n  rawNonce?: string;\n}\n\n/**\n * Common code to all OAuth providers. This is separate from the\n * {@link OAuthProvider} so that child providers (like\n * {@link GoogleAuthProvider}) don't inherit the `credential` instance method.\n * Instead, they rely on a static `credential` method.\n */\nexport abstract class BaseOAuthProvider\n  extends FederatedAuthProvider\n  implements AuthProvider\n{\n  /** @internal */\n  private scopes: string[] = [];\n\n  /**\n   * Add an OAuth scope to the credential.\n   *\n   * @param scope - Provider OAuth scope to add.\n   */\n  addScope(scope: string): AuthProvider {\n    // If not already added, add scope to list.\n    if (!this.scopes.includes(scope)) {\n      this.scopes.push(scope);\n    }\n    return this;\n  }\n\n  /**\n   * Retrieve the current list of OAuth scopes.\n   */\n  getScopes(): string[] {\n    return [...this.scopes];\n  }\n}\n\n/**\n * Provider for generating generic {@link OAuthCredential}.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new OAuthProvider('google.com');\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('profile');\n * provider.addScope('email');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a OAuth Access Token for the provider.\n *   const credential = provider.credentialFromResult(auth, result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new OAuthProvider('google.com');\n * provider.addScope('profile');\n * provider.addScope('email');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a OAuth Access Token for the provider.\n * const credential = provider.credentialFromResult(auth, result);\n * const token = credential.accessToken;\n * ```\n * @public\n */\nexport class OAuthProvider extends BaseOAuthProvider {\n  /**\n   * Creates an {@link OAuthCredential} from a JSON string or a plain object.\n   * @param json - A plain object or a JSON string\n   */\n  static credentialFromJSON(json: object | string): OAuthCredential {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    _assert(\n      'providerId' in obj && 'signInMethod' in obj,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    return OAuthCredential._fromParams(obj);\n  }\n\n  /**\n   * Creates a {@link OAuthCredential} from a generic OAuth provider's access token or ID token.\n   *\n   * @remarks\n   * The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of\n   * the raw nonce must match the nonce field in the ID token.\n   *\n   * @example\n   * ```javascript\n   * // `googleUser` from the onsuccess Google Sign In callback.\n   * // Initialize a generate OAuth provider with a `google.com` providerId.\n   * const provider = new OAuthProvider('google.com');\n   * const credential = provider.credential({\n   *   idToken: googleUser.getAuthResponse().id_token,\n   * });\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param params - Either the options object containing the ID token, access token and raw nonce\n   * or the ID token string.\n   */\n  credential(params: OAuthCredentialOptions): OAuthCredential {\n    return this._credential({ ...params, nonce: params.rawNonce });\n  }\n\n  /** An internal credential method that accepts more permissive options */\n  private _credential(\n    params: Omit<OAuthCredentialParams, 'signInMethod' | 'providerId'>\n  ): OAuthCredential {\n    _assert(params.idToken || params.accessToken, AuthErrorCode.ARGUMENT_ERROR);\n    // For OAuthCredential, sign in method is same as providerId.\n    return OAuthCredential._fromParams({\n      ...params,\n      providerId: this.providerId,\n      signInMethod: this.providerId\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return OAuthProvider.oauthCredentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return OAuthProvider.oauthCredentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static oauthCredentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const {\n      oauthIdToken,\n      oauthAccessToken,\n      oauthTokenSecret,\n      pendingToken,\n      nonce,\n      providerId\n    } = tokenResponse as SignInWithIdpResponse;\n    if (\n      !oauthAccessToken &&\n      !oauthTokenSecret &&\n      !oauthIdToken &&\n      !pendingToken\n    ) {\n      return null;\n    }\n\n    if (!providerId) {\n      return null;\n    }\n\n    try {\n      return new OAuthProvider(providerId)._credential({\n        idToken: oauthIdToken,\n        accessToken: oauthAccessToken,\n        nonce,\n        pendingToken\n      });\n    } catch (e) {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.FACEBOOK.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new FacebookAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('user_birthday');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Facebook Access Token.\n *   const credential = FacebookAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new FacebookAuthProvider();\n * provider.addScope('user_birthday');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Facebook Access Token.\n * const credential = FacebookAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n *\n * @public\n */\nexport class FacebookAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.FACEBOOK. */\n  static readonly FACEBOOK_SIGN_IN_METHOD: 'facebook.com' =\n    SignInMethod.FACEBOOK;\n  /** Always set to {@link ProviderId}.FACEBOOK. */\n  static readonly PROVIDER_ID: 'facebook.com' = ProviderId.FACEBOOK;\n\n  constructor() {\n    super(ProviderId.FACEBOOK);\n  }\n\n  /**\n   * Creates a credential for Facebook.\n   *\n   * @example\n   * ```javascript\n   * // `event` from the Facebook auth.authResponseChange callback.\n   * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param accessToken - Facebook access token.\n   */\n  static credential(accessToken: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: FacebookAuthProvider.PROVIDER_ID,\n      signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return FacebookAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return FacebookAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {\n      return null;\n    }\n\n    if (!tokenResponse.oauthAccessToken) {\n      return null;\n    }\n\n    try {\n      return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GOOGLE.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new GoogleAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('profile');\n * provider.addScope('email');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Google Access Token.\n *   const credential = GoogleAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new GoogleAuthProvider();\n * provider.addScope('profile');\n * provider.addScope('email');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Google Access Token.\n * const credential = GoogleAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n *\n * @public\n */\nexport class GoogleAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.GOOGLE. */\n  static readonly GOOGLE_SIGN_IN_METHOD: 'google.com' = SignInMethod.GOOGLE;\n  /** Always set to {@link ProviderId}.GOOGLE. */\n  static readonly PROVIDER_ID: 'google.com' = ProviderId.GOOGLE;\n\n  constructor() {\n    super(ProviderId.GOOGLE);\n    this.addScope('profile');\n  }\n\n  /**\n   * Creates a credential for Google. At least one of ID token and access token is required.\n   *\n   * @example\n   * ```javascript\n   * // \\`googleUser\\` from the onsuccess Google Sign In callback.\n   * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param idToken - Google ID token.\n   * @param accessToken - Google access token.\n   */\n  static credential(\n    idToken?: string | null,\n    accessToken?: string | null\n  ): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: GoogleAuthProvider.PROVIDER_ID,\n      signInMethod: GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,\n      idToken,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return GoogleAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return GoogleAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const { oauthIdToken, oauthAccessToken } =\n      tokenResponse as SignInWithIdpResponse;\n    if (!oauthIdToken && !oauthAccessToken) {\n      // This could be an oauth 1 credential or a phone credential\n      return null;\n    }\n\n    try {\n      return GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GITHUB.\n *\n * @remarks\n * GitHub requires an OAuth 2.0 redirect, so you can either handle the redirect directly, or use\n * the {@link signInWithPopup} handler:\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new GithubAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('repo');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a GitHub Access Token.\n *   const credential = GithubAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new GithubAuthProvider();\n * provider.addScope('repo');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a GitHub Access Token.\n * const credential = GithubAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n * @public\n */\nexport class GithubAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.GITHUB. */\n  static readonly GITHUB_SIGN_IN_METHOD: 'github.com' = SignInMethod.GITHUB;\n  /** Always set to {@link ProviderId}.GITHUB. */\n  static readonly PROVIDER_ID: 'github.com' = ProviderId.GITHUB;\n\n  constructor() {\n    super(ProviderId.GITHUB);\n  }\n\n  /**\n   * Creates a credential for GitHub.\n   *\n   * @param accessToken - GitHub access token.\n   */\n  static credential(accessToken: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: GithubAuthProvider.PROVIDER_ID,\n      signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return GithubAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return GithubAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {\n      return null;\n    }\n\n    if (!tokenResponse.oauthAccessToken) {\n      return null;\n    }\n\n    try {\n      return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Represents the SAML credentials returned by an {@link SAMLAuthProvider}.\n *\n * @public\n */\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthCredential } from './auth_credential';\n\nconst IDP_REQUEST_URI = 'http://localhost';\n\n/**\n * @public\n */\nexport class SAMLAuthCredential extends AuthCredential {\n  /** @internal */\n  private constructor(\n    providerId: string,\n    private readonly pendingToken: string\n  ) {\n    super(providerId, providerId);\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.idToken = idToken;\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.autoCreate = false;\n    return signInWithIdp(auth, request);\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON}  */\n  toJSON(): object {\n    return {\n      signInMethod: this.signInMethod,\n      providerId: this.providerId,\n      pendingToken: this.pendingToken\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an\n   * {@link  AuthCredential}.\n   *\n   * @param json - Input can be either Object or the stringified representation of the object.\n   * When string is provided, JSON.parse would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.\n   */\n  static fromJSON(json: string | object): SAMLAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    const { providerId, signInMethod, pendingToken }: Record<string, string> =\n      obj;\n    if (\n      !providerId ||\n      !signInMethod ||\n      !pendingToken ||\n      providerId !== signInMethod\n    ) {\n      return null;\n    }\n\n    return new SAMLAuthCredential(providerId, pendingToken);\n  }\n\n  /**\n   * Helper static method to avoid exposing the constructor to end users.\n   *\n   * @internal\n   */\n  static _create(providerId: string, pendingToken: string): SAMLAuthCredential {\n    return new SAMLAuthCredential(providerId, pendingToken);\n  }\n\n  private buildRequest(): SignInWithIdpRequest {\n    return {\n      requestUri: IDP_REQUEST_URI,\n      returnSecureToken: true,\n      pendingToken: this.pendingToken\n    };\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredential } from '../../model/public_types';\nimport { UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { SAMLAuthCredential } from '../credentials/saml';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { FederatedAuthProvider } from './federated';\n\nconst SAML_PROVIDER_PREFIX = 'saml.';\n\n/**\n * An {@link AuthProvider} for SAML.\n *\n * @public\n */\nexport class SAMLAuthProvider extends FederatedAuthProvider {\n  /**\n   * Constructor. The providerId must start with \"saml.\"\n   * @param providerId - SAML provider ID.\n   */\n  constructor(providerId: string) {\n    _assert(\n      providerId.startsWith(SAML_PROVIDER_PREFIX),\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    super(providerId);\n  }\n\n  /**\n   * Generates an {@link AuthCredential} from a {@link UserCredential} after a\n   * successful SAML flow completes.\n   *\n   * @remarks\n   *\n   * For example, to get an {@link AuthCredential}, you could write the\n   * following code:\n   *\n   * ```js\n   * const userCredential = await signInWithPopup(auth, samlProvider);\n   * const credential = SAMLAuthProvider.credentialFromResult(userCredential);\n   * ```\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): AuthCredential | null {\n    return SAMLAuthProvider.samlCredentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): AuthCredential | null {\n    return SAMLAuthProvider.samlCredentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  /**\n   * Creates an {@link AuthCredential} from a JSON string or a plain object.\n   * @param json - A plain object or a JSON string\n   */\n  static credentialFromJSON(json: string | object): AuthCredential {\n    const credential = SAMLAuthCredential.fromJSON(json);\n    _assert(credential, AuthErrorCode.ARGUMENT_ERROR);\n    return credential;\n  }\n\n  private static samlCredentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): SAMLAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const { pendingToken, providerId } = tokenResponse as SignInWithIdpResponse;\n\n    if (!pendingToken || !providerId) {\n      return null;\n    }\n\n    try {\n      return SAMLAuthCredential._create(providerId, pendingToken);\n    } catch (e) {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @license\n * Copyright 2020 Twitter LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.TWITTER.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new TwitterAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Twitter Access Token and Secret.\n *   const credential = TwitterAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n *   const secret = credential.secret;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new TwitterAuthProvider();\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Twitter Access Token and Secret.\n * const credential = TwitterAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * const secret = credential.secret;\n * ```\n *\n * @public\n */\nexport class TwitterAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.TWITTER. */\n  static readonly TWITTER_SIGN_IN_METHOD: 'twitter.com' = SignInMethod.TWITTER;\n  /** Always set to {@link ProviderId}.TWITTER. */\n  static readonly PROVIDER_ID: 'twitter.com' = ProviderId.TWITTER;\n\n  constructor() {\n    super(ProviderId.TWITTER);\n  }\n\n  /**\n   * Creates a credential for Twitter.\n   *\n   * @param token - Twitter access token.\n   * @param secret - Twitter secret.\n   */\n  static credential(token: string, secret: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: TwitterAuthProvider.PROVIDER_ID,\n      signInMethod: TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,\n      oauthToken: token,\n      oauthTokenSecret: secret\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return TwitterAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return TwitterAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n    const { oauthAccessToken, oauthTokenSecret } =\n      tokenResponse as SignInWithIdpResponse;\n    if (!oauthAccessToken || !oauthTokenSecret) {\n      return null;\n    }\n\n    try {\n      return TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);\n    } catch {\n      return null;\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignUpRequest {\n  idToken?: string;\n  returnSecureToken?: boolean;\n  email?: string;\n  password?: string;\n  tenantId?: string;\n  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface SignUpResponse extends IdTokenResponse {\n  displayName?: string;\n  email?: string;\n}\n\nexport async function signUp(\n  auth: Auth,\n  request: SignUpRequest\n): Promise<SignUpResponse> {\n  return _performSignInRequest<SignUpRequest, SignUpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_UP,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { UserImpl } from './user_impl';\nimport { AuthInternal } from '../../model/auth';\nimport { OperationType, ProviderId } from '../../model/enums';\n\ninterface UserCredentialParams {\n  readonly user: UserInternal;\n  readonly providerId: ProviderId | string | null;\n  readonly _tokenResponse?: PhoneOrOauthTokenResponse;\n  readonly operationType: OperationType;\n}\n\nexport class UserCredentialImpl\n  implements UserCredentialInternal, UserCredentialParams\n{\n  readonly user: UserInternal;\n  readonly providerId: ProviderId | string | null;\n  readonly _tokenResponse: PhoneOrOauthTokenResponse | undefined;\n  readonly operationType: OperationType;\n\n  constructor(params: UserCredentialParams) {\n    this.user = params.user;\n    this.providerId = params.providerId;\n    this._tokenResponse = params._tokenResponse;\n    this.operationType = params.operationType;\n  }\n\n  static async _fromIdTokenResponse(\n    auth: AuthInternal,\n    operationType: OperationType,\n    idTokenResponse: IdTokenResponse,\n    isAnonymous: boolean = false\n  ): Promise<UserCredentialInternal> {\n    const user = await UserImpl._fromIdTokenResponse(\n      auth,\n      idTokenResponse,\n      isAnonymous\n    );\n    const providerId = providerIdForResponse(idTokenResponse);\n    const userCred = new UserCredentialImpl({\n      user,\n      providerId,\n      _tokenResponse: idTokenResponse,\n      operationType\n    });\n    return userCred;\n  }\n\n  static async _forOperation(\n    user: UserInternal,\n    operationType: OperationType,\n    response: PhoneOrOauthTokenResponse\n  ): Promise<UserCredentialImpl> {\n    await user._updateTokensIfNecessary(response, /* reload */ true);\n    const providerId = providerIdForResponse(response);\n    return new UserCredentialImpl({\n      user,\n      providerId,\n      _tokenResponse: response,\n      operationType\n    });\n  }\n}\n\nfunction providerIdForResponse(\n  response: IdTokenResponse\n): ProviderId | string | null {\n  if (response.providerId) {\n    return response.providerId;\n  }\n\n  if ('phoneNumber' in response) {\n    return ProviderId.PHONE;\n  }\n\n  return null;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, UserCredential } from '../../model/public_types';\nimport { signUp } from '../../api/authentication/sign_up';\nimport { UserInternal } from '../../model/user';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { OperationType } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\n/**\n * Asynchronously signs in as an anonymous user.\n *\n * @remarks\n * If there is already an anonymous user signed in, that user will be returned; otherwise, a\n * new anonymous user identity will be created and returned.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport async function signInAnonymously(auth: Auth): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authInternal = _castAuth(auth);\n  await authInternal._initializationPromise;\n  if (authInternal.currentUser?.isAnonymous) {\n    // If an anonymous user is already signed in, no need to sign them in again.\n    return new UserCredentialImpl({\n      user: authInternal.currentUser as UserInternal,\n      providerId: null,\n      operationType: OperationType.SIGN_IN\n    });\n  }\n  const response = await signUp(authInternal, {\n    returnSecureToken: true\n  });\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response,\n    true\n  );\n  await authInternal._updateCurrentUser(userCredential.user);\n  return userCredential;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { MultiFactorError as MultiFactorErrorPublic } from '../model/public_types';\nimport { FirebaseError } from '@firebase/util';\nimport { AuthInternal } from '../model/auth';\nimport { IdTokenResponse } from '../model/id_token';\nimport { AuthErrorCode } from '../core/errors';\nimport { UserInternal } from '../model/user';\nimport { AuthCredential } from '../core/credentials';\nimport { IdTokenMfaResponse } from '../api/authentication/mfa';\nimport { OperationType } from '../model/enums';\n\nexport type MultiFactorErrorData = MultiFactorErrorPublic['customData'] & {\n  _serverResponse: IdTokenMfaResponse;\n};\n\nexport class MultiFactorError\n  extends FirebaseError\n  implements MultiFactorErrorPublic\n{\n  readonly customData: MultiFactorErrorData;\n\n  private constructor(\n    auth: AuthInternal,\n    error: FirebaseError,\n    readonly operationType: OperationType,\n    readonly user?: UserInternal\n  ) {\n    super(error.code, error.message);\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    Object.setPrototypeOf(this, MultiFactorError.prototype);\n    this.customData = {\n      appName: auth.name,\n      tenantId: auth.tenantId ?? undefined,\n      _serverResponse: error.customData!._serverResponse as IdTokenMfaResponse,\n      operationType\n    };\n  }\n\n  static _fromErrorAndOperation(\n    auth: AuthInternal,\n    error: FirebaseError,\n    operationType: OperationType,\n    user?: UserInternal\n  ): MultiFactorError {\n    return new MultiFactorError(auth, error, operationType, user);\n  }\n}\n\nexport function _processCredentialSavingMfaContextIfNecessary(\n  auth: AuthInternal,\n  operationType: OperationType,\n  credential: AuthCredential,\n  user?: UserInternal\n): Promise<IdTokenResponse> {\n  const idTokenProvider =\n    operationType === OperationType.REAUTHENTICATE\n      ? credential._getReauthenticationResolver(auth)\n      : credential._getIdTokenResponse(auth);\n\n  return idTokenProvider.catch(error => {\n    if (error.code === `auth/${AuthErrorCode.MFA_REQUIRED}`) {\n      throw MultiFactorError._fromErrorAndOperation(\n        auth,\n        error,\n        operationType,\n        user\n      );\n    }\n\n    throw error;\n  });\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface ProviderAssociatedObject {\n  providerId?: string;\n}\n\n/**\n * Takes a set of UserInfo provider data and converts it to a set of names\n */\nexport function providerDataAsNames<T extends ProviderAssociatedObject>(\n  providerData: T[]\n): Set<string> {\n  return new Set(\n    providerData\n      .map(({ providerId }) => providerId)\n      .filter(pid => !!pid) as string[]\n  );\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User } from '../../model/public_types';\n\nimport { deleteLinkedAccounts } from '../../api/account_management/account';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { providerDataAsNames } from '../util/providers';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { _reloadWithoutSaving } from './reload';\nimport { UserCredentialImpl } from './user_credential_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType, ProviderId } from '../../model/enums';\n\n/**\n * Unlinks a provider from a user account.\n *\n * @param user - The user.\n * @param providerId - The provider to unlink.\n *\n * @public\n */\nexport async function unlink(user: User, providerId: string): Promise<User> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  await _assertLinkedStatus(true, userInternal, providerId);\n  const { providerUserInfo } = await deleteLinkedAccounts(userInternal.auth, {\n    idToken: await userInternal.getIdToken(),\n    deleteProvider: [providerId]\n  });\n\n  const providersLeft = providerDataAsNames(providerUserInfo || []);\n\n  userInternal.providerData = userInternal.providerData.filter(pd =>\n    providersLeft.has(pd.providerId)\n  );\n  if (!providersLeft.has(ProviderId.PHONE)) {\n    userInternal.phoneNumber = null;\n  }\n\n  await userInternal.auth._persistUserIfCurrent(userInternal);\n  return userInternal;\n}\n\nexport async function _link(\n  user: UserInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredentialInternal> {\n  const response = await _logoutIfInvalidated(\n    user,\n    credential._linkToIdToken(user.auth, await user.getIdToken()),\n    bypassAuthState\n  );\n  return UserCredentialImpl._forOperation(user, OperationType.LINK, response);\n}\n\nexport async function _assertLinkedStatus(\n  expected: boolean,\n  user: UserInternal,\n  provider: string\n): Promise<void> {\n  await _reloadWithoutSaving(user);\n  const providerIds = providerDataAsNames(user.providerData);\n\n  const code =\n    expected === false\n      ? AuthErrorCode.PROVIDER_ALREADY_LINKED\n      : AuthErrorCode.NO_SUCH_PROVIDER;\n  _assert(providerIds.has(provider) === expected, user.auth, code);\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';\nimport { OperationType } from '../../model/enums';\nimport { UserInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { AuthErrorCode } from '../errors';\nimport { _assert, _fail } from '../util/assert';\nimport { _parseToken } from './id_token_result';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { UserCredentialImpl } from './user_credential_impl';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\nexport async function _reauthenticate(\n  user: UserInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredentialImpl> {\n  const { auth } = user;\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const operationType = OperationType.REAUTHENTICATE;\n\n  try {\n    const response = await _logoutIfInvalidated(\n      user,\n      _processCredentialSavingMfaContextIfNecessary(\n        auth,\n        operationType,\n        credential,\n        user\n      ),\n      bypassAuthState\n    );\n    _assert(response.idToken, auth, AuthErrorCode.INTERNAL_ERROR);\n    const parsed = _parseToken(response.idToken);\n    _assert(parsed, auth, AuthErrorCode.INTERNAL_ERROR);\n\n    const { sub: localId } = parsed;\n    _assert(user.uid === localId, auth, AuthErrorCode.USER_MISMATCH);\n\n    return UserCredentialImpl._forOperation(user, operationType, response);\n  } catch (e) {\n    // Convert user deleted error into user mismatch\n    if ((e as FirebaseError)?.code === `auth/${AuthErrorCode.USER_DELETED}`) {\n      _fail(auth, AuthErrorCode.USER_MISMATCH);\n    }\n    throw e;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential, Auth, User } from '../../model/public_types';\n\nimport { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';\nimport { AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { _assertLinkedStatus, _link } from '../user/link_unlink';\nimport { _reauthenticate } from '../user/reauthenticate';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\nexport async function _signInWithCredential(\n  auth: AuthInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const operationType = OperationType.SIGN_IN;\n  const response = await _processCredentialSavingMfaContextIfNecessary(\n    auth,\n    operationType,\n    credential\n  );\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    auth,\n    operationType,\n    response\n  );\n\n  if (!bypassAuthState) {\n    await auth._updateCurrentUser(userCredential.user);\n  }\n  return userCredential;\n}\n\n/**\n * Asynchronously signs in with the given credentials.\n *\n * @remarks\n * An {@link AuthProvider} can be used to generate the credential.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function signInWithCredential(\n  auth: Auth,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  return _signInWithCredential(_castAuth(auth), credential);\n}\n\n/**\n * Links the user account with the given credentials.\n *\n * @remarks\n * An {@link AuthProvider} can be used to generate the credential.\n *\n * @param user - The user.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function linkWithCredential(\n  user: User,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  const userInternal = getModularInstance(user) as UserInternal;\n\n  await _assertLinkedStatus(false, userInternal, credential.providerId);\n\n  return _link(userInternal, credential);\n}\n\n/**\n * Re-authenticates a user using a fresh credential.\n *\n * @remarks\n * Use before operations such as {@link updatePassword} that require tokens from recent sign-in\n * attempts. This method can be used to recover from a `CREDENTIAL_TOO_OLD_LOGIN_AGAIN` error\n * or a `TOKEN_EXPIRED` error.\n *\n * This method is not supported on any {@link User} signed in by {@link Auth} instances\n * created with a {@link @firebase/app#FirebaseServerApp}.\n *\n * @param user - The user.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function reauthenticateWithCredential(\n  user: User,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  return _reauthenticate(getModularInstance(user) as UserInternal, credential);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithCustomTokenRequest {\n  token: string;\n  returnSecureToken: boolean;\n  tenantId?: string;\n}\n\nexport interface SignInWithCustomTokenResponse extends IdTokenResponse {}\n\nexport async function signInWithCustomToken(\n  auth: Auth,\n  request: SignInWithCustomTokenRequest\n): Promise<SignInWithCustomTokenResponse> {\n  return _performSignInRequest<\n    SignInWithCustomTokenRequest,\n    SignInWithCustomTokenResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_CUSTOM_TOKEN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, UserCredential } from '../../model/public_types';\n\nimport { signInWithCustomToken as getIdTokenResponse } from '../../api/authentication/custom_token';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { OperationType } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n/**\n * Asynchronously signs in using a custom token.\n *\n * @remarks\n * Custom tokens are used to integrate Firebase Auth with existing auth systems, and must\n * be generated by an auth backend using the\n * {@link https://firebase.google.com/docs/reference/admin/node/admin.auth.Auth#createcustomtoken | createCustomToken}\n * method in the {@link https://firebase.google.com/docs/auth/admin | Admin SDK} .\n *\n * Fails with an error if the token is invalid, expired, or not accepted by the Firebase Auth service.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n * @param customToken - The custom token to sign in with.\n *\n * @public\n */\nexport async function signInWithCustomToken(\n  auth: Auth,\n  customToken: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authInternal = _castAuth(auth);\n  const response: IdTokenResponse = await getIdTokenResponse(authInternal, {\n    token: customToken,\n    returnSecureToken: true\n  });\n  const cred = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response\n  );\n  await authInternal._updateCurrentUser(cred.user);\n  return cred;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FactorId,\n  MultiFactorInfo,\n  PhoneMultiFactorInfo,\n  TotpMultiFactorInfo\n} from '../model/public_types';\nimport {\n  PhoneMfaEnrollment,\n  MfaEnrollment,\n  TotpMfaEnrollment\n} from '../api/account_management/mfa';\nimport { AuthErrorCode } from '../core/errors';\nimport { _fail } from '../core/util/assert';\nimport { AuthInternal } from '../model/auth';\n\nexport abstract class MultiFactorInfoImpl implements MultiFactorInfo {\n  readonly uid: string;\n  readonly displayName?: string | null;\n  readonly enrollmentTime: string;\n\n  protected constructor(readonly factorId: FactorId, response: MfaEnrollment) {\n    this.uid = response.mfaEnrollmentId;\n    this.enrollmentTime = new Date(response.enrolledAt).toUTCString();\n    this.displayName = response.displayName;\n  }\n\n  static _fromServerResponse(\n    auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): MultiFactorInfoImpl {\n    if ('phoneInfo' in enrollment) {\n      return PhoneMultiFactorInfoImpl._fromServerResponse(auth, enrollment);\n    } else if ('totpInfo' in enrollment) {\n      return TotpMultiFactorInfoImpl._fromServerResponse(auth, enrollment);\n    }\n    return _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n  }\n}\n\nexport class PhoneMultiFactorInfoImpl\n  extends MultiFactorInfoImpl\n  implements PhoneMultiFactorInfo\n{\n  readonly phoneNumber: string;\n\n  private constructor(response: PhoneMfaEnrollment) {\n    super(FactorId.PHONE, response);\n    this.phoneNumber = response.phoneInfo;\n  }\n\n  static _fromServerResponse(\n    _auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): PhoneMultiFactorInfoImpl {\n    return new PhoneMultiFactorInfoImpl(enrollment as PhoneMfaEnrollment);\n  }\n}\nexport class TotpMultiFactorInfoImpl\n  extends MultiFactorInfoImpl\n  implements TotpMultiFactorInfo\n{\n  private constructor(response: TotpMfaEnrollment) {\n    super(FactorId.TOTP, response);\n  }\n\n  static _fromServerResponse(\n    _auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): TotpMultiFactorInfoImpl {\n    return new TotpMultiFactorInfoImpl(enrollment as TotpMfaEnrollment);\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeSettings, Auth } from '../../model/public_types';\n\nimport { GetOobCodeRequest } from '../../api/authentication/email_and_password';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\n\nexport function _setActionCodeSettingsOnRequest(\n  auth: Auth,\n  request: GetOobCodeRequest,\n  actionCodeSettings: ActionCodeSettings\n): void {\n  _assert(\n    actionCodeSettings.url?.length > 0,\n    auth,\n    AuthErrorCode.INVALID_CONTINUE_URI\n  );\n  _assert(\n    typeof actionCodeSettings.dynamicLinkDomain === 'undefined' ||\n      actionCodeSettings.dynamicLinkDomain.length > 0,\n    auth,\n    AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN\n  );\n  _assert(\n    typeof actionCodeSettings.linkDomain === 'undefined' ||\n      actionCodeSettings.linkDomain.length > 0,\n    auth,\n    AuthErrorCode.INVALID_HOSTING_LINK_DOMAIN\n  );\n\n  request.continueUrl = actionCodeSettings.url;\n  request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;\n  request.linkDomain = actionCodeSettings.linkDomain;\n  request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;\n\n  if (actionCodeSettings.iOS) {\n    _assert(\n      actionCodeSettings.iOS.bundleId.length > 0,\n      auth,\n      AuthErrorCode.MISSING_IOS_BUNDLE_ID\n    );\n    request.iOSBundleId = actionCodeSettings.iOS.bundleId;\n  }\n\n  if (actionCodeSettings.android) {\n    _assert(\n      actionCodeSettings.android.packageName.length > 0,\n      auth,\n      AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME\n    );\n    request.androidInstallApp = actionCodeSettings.android.installApp;\n    request.androidMinimumVersionCode =\n      actionCodeSettings.android.minimumVersion;\n    request.androidPackageName = actionCodeSettings.android.packageName;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeInfo,\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  UserCredential\n} from '../../model/public_types';\n\nimport * as account from '../../api/account_management/email_and_password';\nimport * as authentication from '../../api/authentication/email_and_password';\nimport { signUp, SignUpRequest } from '../../api/authentication/sign_up';\nimport { MultiFactorInfoImpl } from '../../mfa/mfa_info';\nimport { EmailAuthProvider } from '../providers/email';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport {\n  _assert,\n  _serverAppCurrentUserOperationNotSupportedError\n} from '../util/assert';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { signInWithCredential } from './credential';\nimport { _castAuth } from '../auth/auth_impl';\nimport { AuthErrorCode } from '../errors';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../../model/enums';\nimport { handleRecaptchaFlow } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { IdTokenResponse } from '../../model/id_token';\nimport {\n  RecaptchaActionName,\n  RecaptchaClientType,\n  RecaptchaAuthProvider\n} from '../../api';\nimport { _isFirebaseServerApp } from '@firebase/app';\n\n/**\n * Updates the password policy cached in the {@link Auth} instance if a policy is already\n * cached for the project or tenant.\n *\n * @remarks\n * We only fetch the password policy if the password did not meet policy requirements and\n * there is an existing policy cached. A developer must call validatePassword at least\n * once for the cache to be automatically updated.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @private\n */\nasync function recachePasswordPolicy(auth: Auth): Promise<void> {\n  const authInternal = _castAuth(auth);\n  if (authInternal._getPasswordPolicyInternal()) {\n    await authInternal._updatePasswordPolicy();\n  }\n}\n\n/**\n * Sends a password reset email to the given email address. This method does not throw an error when\n * there's no user account with the given email address and\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled.\n *\n * @remarks\n * To complete the password reset, call {@link confirmPasswordReset} with the code supplied in\n * the email sent to the user, along with the new password specified by the user.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendPasswordResetEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain code from user.\n * await confirmPasswordReset('user@example.com', code);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendPasswordResetEmail(\n  auth: Auth,\n  email: string,\n  actionCodeSettings?: ActionCodeSettings\n): Promise<void> {\n  const authInternal = _castAuth(auth);\n  const request: authentication.PasswordResetRequest = {\n    requestType: ActionCodeOperation.PASSWORD_RESET,\n    email,\n    clientType: RecaptchaClientType.WEB\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(authInternal, request, actionCodeSettings);\n  }\n  await handleRecaptchaFlow(\n    authInternal,\n    request,\n    RecaptchaActionName.GET_OOB_CODE,\n    authentication.sendPasswordResetEmail,\n    RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n  );\n}\n\n/**\n * Completes the password reset process, given a confirmation code and new password.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A confirmation code sent to the user.\n * @param newPassword - The new password.\n *\n * @public\n */\nexport async function confirmPasswordReset(\n  auth: Auth,\n  oobCode: string,\n  newPassword: string\n): Promise<void> {\n  await account\n    .resetPassword(getModularInstance(auth), {\n      oobCode,\n      newPassword\n    })\n    .catch(async error => {\n      if (\n        error.code ===\n        `auth/${AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS}`\n      ) {\n        void recachePasswordPolicy(auth);\n      }\n\n      throw error;\n    });\n  // Do not return the email.\n}\n\n/**\n * Applies a verification code sent to the user by email or other out-of-band mechanism.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A verification code sent to the user.\n *\n * @public\n */\nexport async function applyActionCode(\n  auth: Auth,\n  oobCode: string\n): Promise<void> {\n  await account.applyActionCode(getModularInstance(auth), { oobCode });\n}\n\n/**\n * Checks a verification code sent to the user by email or other out-of-band mechanism.\n *\n * @returns metadata about the code.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A verification code sent to the user.\n *\n * @public\n */\nexport async function checkActionCode(\n  auth: Auth,\n  oobCode: string\n): Promise<ActionCodeInfo> {\n  const authModular = getModularInstance(auth);\n  const response = await account.resetPassword(authModular, { oobCode });\n\n  // Email could be empty only if the request type is EMAIL_SIGNIN or\n  // VERIFY_AND_CHANGE_EMAIL.\n  // New email should not be empty if the request type is\n  // VERIFY_AND_CHANGE_EMAIL.\n  // Multi-factor info could not be empty if the request type is\n  // REVERT_SECOND_FACTOR_ADDITION.\n  const operation = response.requestType;\n  _assert(operation, authModular, AuthErrorCode.INTERNAL_ERROR);\n  switch (operation) {\n    case ActionCodeOperation.EMAIL_SIGNIN:\n      break;\n    case ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL:\n      _assert(response.newEmail, authModular, AuthErrorCode.INTERNAL_ERROR);\n      break;\n    case ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION:\n      _assert(response.mfaInfo, authModular, AuthErrorCode.INTERNAL_ERROR);\n    // fall through\n    default:\n      _assert(response.email, authModular, AuthErrorCode.INTERNAL_ERROR);\n  }\n\n  // The multi-factor info for revert second factor addition\n  let multiFactorInfo: MultiFactorInfoImpl | null = null;\n  if (response.mfaInfo) {\n    multiFactorInfo = MultiFactorInfoImpl._fromServerResponse(\n      _castAuth(authModular),\n      response.mfaInfo\n    );\n  }\n\n  return {\n    data: {\n      email:\n        (response.requestType === ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL\n          ? response.newEmail\n          : response.email) || null,\n      previousEmail:\n        (response.requestType === ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL\n          ? response.email\n          : response.newEmail) || null,\n      multiFactorInfo\n    },\n    operation\n  };\n}\n\n/**\n * Checks a password reset code sent to the user by email or other out-of-band mechanism.\n *\n * @returns the user's email address if valid.\n *\n * @param auth - The {@link Auth} instance.\n * @param code - A verification code sent to the user.\n *\n * @public\n */\nexport async function verifyPasswordResetCode(\n  auth: Auth,\n  code: string\n): Promise<string> {\n  const { data } = await checkActionCode(getModularInstance(auth), code);\n  // Email should always be present since a code was sent to it\n  return data.email!;\n}\n\n/**\n * Creates a new user account associated with the specified email address and password.\n *\n * @remarks\n * On successful creation of the user account, this user will also be signed in to your application.\n *\n * User account creation can fail if the account already exists or the password is invalid.\n *\n * This method is not supported on {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * Note: The email address acts as a unique identifier for the user and enables an email-based\n * password reset. This function will create a new user account and set the initial user password.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param password - The user's chosen password.\n *\n * @public\n */\nexport async function createUserWithEmailAndPassword(\n  auth: Auth,\n  email: string,\n  password: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authInternal = _castAuth(auth);\n  const request: SignUpRequest = {\n    returnSecureToken: true,\n    email,\n    password,\n    clientType: RecaptchaClientType.WEB\n  };\n  const signUpResponse: Promise<IdTokenResponse> = handleRecaptchaFlow(\n    authInternal,\n    request,\n    RecaptchaActionName.SIGN_UP_PASSWORD,\n    signUp,\n    RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n  );\n  const response = await signUpResponse.catch(error => {\n    if (\n      error.code === `auth/${AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS}`\n    ) {\n      void recachePasswordPolicy(auth);\n    }\n\n    throw error;\n  });\n\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response\n  );\n  await authInternal._updateCurrentUser(userCredential.user);\n\n  return userCredential;\n}\n\n/**\n * Asynchronously signs in using an email and password.\n *\n * @remarks\n * Fails with an error if the email address and password do not match. When\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled, this method fails with \"auth/invalid-credential\" in case of an invalid\n * email/password.\n *\n * This method is not supported on {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * Note: The user's password is NOT the password used to access the user's email account. The\n * email address serves as a unique identifier for the user, and the password is used to access\n * the user's account in your Firebase project. See also: {@link createUserWithEmailAndPassword}.\n *\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The users email address.\n * @param password - The users password.\n *\n * @public\n */\nexport function signInWithEmailAndPassword(\n  auth: Auth,\n  email: string,\n  password: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  return signInWithCredential(\n    getModularInstance(auth),\n    EmailAuthProvider.credential(email, password)\n  ).catch(async error => {\n    if (\n      error.code === `auth/${AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS}`\n    ) {\n      void recachePasswordPolicy(auth);\n    }\n\n    throw error;\n  });\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  UserCredential\n} from '../../model/public_types';\n\nimport * as api from '../../api/authentication/email_and_password';\nimport { ActionCodeURL } from '../action_code_url';\nimport { EmailAuthProvider } from '../providers/email';\nimport { _getCurrentUrl } from '../util/location';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { signInWithCredential } from './credential';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { getModularInstance } from '@firebase/util';\nimport { _castAuth } from '../auth/auth_impl';\nimport { handleRecaptchaFlow } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport {\n  RecaptchaActionName,\n  RecaptchaClientType,\n  RecaptchaAuthProvider\n} from '../../api';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\n/**\n * Sends a sign-in email link to the user with the specified email.\n *\n * @remarks\n * The sign-in operation has to always be completed in the app unlike other out of band email\n * actions (password reset and email verifications). This is because, at the end of the flow,\n * the user is expected to be signed in and their Auth state persisted within the app.\n *\n * To complete sign in with the email link, call {@link signInWithEmailLink} with the email\n * address and the email link supplied in the email sent to the user.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain emailLink from the user.\n * if(isSignInWithEmailLink(auth, emailLink)) {\n *   await signInWithEmailLink(auth, 'user@example.com', emailLink);\n * }\n * ```\n *\n * @param authInternal - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendSignInLinkToEmail(\n  auth: Auth,\n  email: string,\n  actionCodeSettings: ActionCodeSettings\n): Promise<void> {\n  const authInternal = _castAuth(auth);\n  const request: api.EmailSignInRequest = {\n    requestType: ActionCodeOperation.EMAIL_SIGNIN,\n    email,\n    clientType: RecaptchaClientType.WEB\n  };\n  function setActionCodeSettings(\n    request: api.EmailSignInRequest,\n    actionCodeSettings: ActionCodeSettings\n  ): void {\n    _assert(\n      actionCodeSettings.handleCodeInApp,\n      authInternal,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    if (actionCodeSettings) {\n      _setActionCodeSettingsOnRequest(\n        authInternal,\n        request,\n        actionCodeSettings\n      );\n    }\n  }\n  setActionCodeSettings(request, actionCodeSettings);\n  await handleRecaptchaFlow(\n    authInternal,\n    request,\n    RecaptchaActionName.GET_OOB_CODE,\n    api.sendSignInLinkToEmail,\n    RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER\n  );\n}\n\n/**\n * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.\n *\n * @param auth - The {@link Auth} instance.\n * @param emailLink - The link sent to the user's email address.\n *\n * @public\n */\nexport function isSignInWithEmailLink(auth: Auth, emailLink: string): boolean {\n  const actionCodeUrl = ActionCodeURL.parseLink(emailLink);\n  return actionCodeUrl?.operation === ActionCodeOperation.EMAIL_SIGNIN;\n}\n\n/**\n * Asynchronously signs in using an email and sign-in email link.\n *\n * @remarks\n * If no link is passed, the link is inferred from the current URL.\n *\n * Fails with an error if the email address is invalid or OTP in email link expires.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * Note: Confirm the link is a sign-in email link before calling this method firebase.auth.Auth.isSignInWithEmailLink.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain emailLink from the user.\n * if(isSignInWithEmailLink(auth, emailLink)) {\n *   await signInWithEmailLink(auth, 'user@example.com', emailLink);\n * }\n * ```\n *\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param emailLink - The link sent to the user's email address.\n *\n * @public\n */\nexport async function signInWithEmailLink(\n  auth: Auth,\n  email: string,\n  emailLink?: string\n): Promise<UserCredential> {\n  if (_isFirebaseServerApp(auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(auth)\n    );\n  }\n  const authModular = getModularInstance(auth);\n  const credential = EmailAuthProvider.credentialWithLink(\n    email,\n    emailLink || _getCurrentUrl()\n  );\n  // Check if the tenant ID in the email link matches the tenant ID on Auth\n  // instance.\n  _assert(\n    credential._tenantId === (authModular.tenantId || null),\n    authModular,\n    AuthErrorCode.TENANT_ID_MISMATCH\n  );\n  return signInWithCredential(authModular, credential);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\nexport interface CreateAuthUriRequest {\n  identifier: string;\n  continueUri: string;\n  tenantId?: string;\n}\n\nexport interface CreateAuthUriResponse {\n  signinMethods: string[];\n}\n\nexport async function createAuthUri(\n  auth: Auth,\n  request: CreateAuthUriRequest\n): Promise<CreateAuthUriResponse> {\n  return _performApiRequest<CreateAuthUriRequest, CreateAuthUriResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.CREATE_AUTH_URI,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  User\n} from '../../model/public_types';\n\nimport {\n  createAuthUri,\n  CreateAuthUriRequest\n} from '../../api/authentication/create_auth_uri';\nimport * as api from '../../api/authentication/email_and_password';\nimport { UserInternal } from '../../model/user';\nimport { _getCurrentUrl, _isHttpOrHttps } from '../util/location';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { getModularInstance } from '@firebase/util';\n\n/**\n * Gets the list of possible sign in methods for the given email address. This method returns an\n * empty list when\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled, irrespective of the number of authentication methods available for the given email.\n *\n * @remarks\n * This is useful to differentiate methods of sign-in for the same provider, eg.\n * {@link EmailAuthProvider} which has 2 methods of sign-in,\n * {@link SignInMethod}.EMAIL_PASSWORD and\n * {@link SignInMethod}.EMAIL_LINK.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n *\n * Deprecated. Migrating off of this method is recommended as a security best-practice.\n * Learn more in the Identity Platform documentation for\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}.\n * @public\n */\nexport async function fetchSignInMethodsForEmail(\n  auth: Auth,\n  email: string\n): Promise<string[]> {\n  // createAuthUri returns an error if continue URI is not http or https.\n  // For environments like Cordova, Chrome extensions, native frameworks, file\n  // systems, etc, use http://localhost as continue URL.\n  const continueUri = _isHttpOrHttps() ? _getCurrentUrl() : 'http://localhost';\n  const request: CreateAuthUriRequest = {\n    identifier: email,\n    continueUri\n  };\n\n  const { signinMethods } = await createAuthUri(\n    getModularInstance(auth),\n    request\n  );\n\n  return signinMethods || [];\n}\n\n/**\n * Sends a verification email to a user.\n *\n * @remarks\n * The verification process is completed by calling {@link applyActionCode}.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendEmailVerification(user, actionCodeSettings);\n * // Obtain code from the user.\n * await applyActionCode(auth, code);\n * ```\n *\n * @param user - The user.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendEmailVerification(\n  user: User,\n  actionCodeSettings?: ActionCodeSettings | null\n): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await user.getIdToken();\n  const request: api.VerifyEmailRequest = {\n    requestType: ActionCodeOperation.VERIFY_EMAIL,\n    idToken\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(\n      userInternal.auth,\n      request,\n      actionCodeSettings\n    );\n  }\n\n  const { email } = await api.sendEmailVerification(userInternal.auth, request);\n\n  if (email !== user.email) {\n    await user.reload();\n  }\n}\n\n/**\n * Sends a verification email to a new email address.\n *\n * @remarks\n * The user's email will be updated to the new one after being verified.\n *\n * If you have a custom email action handler, you can complete the verification process by calling\n * {@link applyActionCode}.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await verifyBeforeUpdateEmail(user, 'newemail@example.com', actionCodeSettings);\n * // Obtain code from the user.\n * await applyActionCode(auth, code);\n * ```\n *\n * @param user - The user.\n * @param newEmail - The new email address to be verified before update.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function verifyBeforeUpdateEmail(\n  user: User,\n  newEmail: string,\n  actionCodeSettings?: ActionCodeSettings | null\n): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await user.getIdToken();\n  const request: api.VerifyAndChangeEmailRequest = {\n    requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL,\n    idToken,\n    newEmail\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(\n      userInternal.auth,\n      request,\n      actionCodeSettings\n    );\n  }\n\n  const { email } = await api.verifyAndChangeEmail(userInternal.auth, request);\n\n  if (email !== user.email) {\n    // If the local copy of the email on user is outdated, reload the\n    // user.\n    await user.reload();\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface UpdateProfileRequest {\n  idToken: string;\n  displayName?: string | null;\n  photoUrl?: string | null;\n  returnSecureToken: boolean;\n}\n\nexport interface UpdateProfileResponse extends IdTokenResponse {\n  displayName?: string | null;\n  photoUrl?: string | null;\n}\n\nexport async function updateProfile(\n  auth: Auth,\n  request: UpdateProfileRequest\n): Promise<UpdateProfileResponse> {\n  return _performApiRequest<UpdateProfileRequest, UpdateProfileResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SET_ACCOUNT_INFO,\n    request\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User } from '../../model/public_types';\n\nimport {\n  updateEmailPassword as apiUpdateEmailPassword,\n  UpdateEmailPasswordRequest\n} from '../../api/account_management/email_and_password';\nimport { updateProfile as apiUpdateProfile } from '../../api/account_management/profile';\nimport { UserInternal } from '../../model/user';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { getModularInstance } from '@firebase/util';\nimport { ProviderId } from '../../model/enums';\nimport { _isFirebaseServerApp } from '@firebase/app';\nimport { _serverAppCurrentUserOperationNotSupportedError } from '../../core/util/assert';\n\n/**\n * Updates a user's profile data.\n *\n * @param user - The user.\n * @param profile - The profile's `displayName` and `photoURL` to update.\n *\n * @public\n */\nexport async function updateProfile(\n  user: User,\n  {\n    displayName,\n    photoURL: photoUrl\n  }: { displayName?: string | null; photoURL?: string | null }\n): Promise<void> {\n  if (displayName === undefined && photoUrl === undefined) {\n    return;\n  }\n\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await userInternal.getIdToken();\n  const profileRequest = {\n    idToken,\n    displayName,\n    photoUrl,\n    returnSecureToken: true\n  };\n  const response = await _logoutIfInvalidated(\n    userInternal,\n    apiUpdateProfile(userInternal.auth, profileRequest)\n  );\n\n  userInternal.displayName = response.displayName || null;\n  userInternal.photoURL = response.photoUrl || null;\n\n  // Update the password provider as well\n  const passwordProvider = userInternal.providerData.find(\n    ({ providerId }) => providerId === ProviderId.PASSWORD\n  );\n  if (passwordProvider) {\n    passwordProvider.displayName = userInternal.displayName;\n    passwordProvider.photoURL = userInternal.photoURL;\n  }\n\n  await userInternal._updateTokensIfNecessary(response);\n}\n\n/**\n * Updates the user's email address.\n *\n * @remarks\n * An email will be sent to the original email address (if it was set) that allows to revoke the\n * email address change, in order to protect them from account hijacking.\n *\n * This method is not supported on any {@link User} signed in by {@link Auth} instances\n * created with a {@link @firebase/app#FirebaseServerApp}.\n *\n * Important: this is a security sensitive operation that requires the user to have recently signed\n * in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n * @param newEmail - The new email address.\n *\n * Throws \"auth/operation-not-allowed\" error when\n * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}\n * is enabled.\n * Deprecated - Use {@link verifyBeforeUpdateEmail} instead.\n *\n * @public\n */\nexport function updateEmail(user: User, newEmail: string): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  if (_isFirebaseServerApp(userInternal.auth.app)) {\n    return Promise.reject(\n      _serverAppCurrentUserOperationNotSupportedError(userInternal.auth)\n    );\n  }\n  return updateEmailOrPassword(userInternal, newEmail, null);\n}\n\n/**\n * Updates the user's password.\n *\n * @remarks\n * Important: this is a security sensitive operation that requires the user to have recently signed\n * in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n * @param newPassword - The new password.\n *\n * @public\n */\nexport function updatePassword(user: User, newPassword: string): Promise<void> {\n  return updateEmailOrPassword(\n    getModularInstance(user) as UserInternal,\n    null,\n    newPassword\n  );\n}\n\nasync function updateEmailOrPassword(\n  user: UserInternal,\n  email: string | null,\n  password: string | null\n): Promise<void> {\n  const { auth } = user;\n  const idToken = await user.getIdToken();\n  const request: UpdateEmailPasswordRequest = {\n    idToken,\n    returnSecureToken: true\n  };\n\n  if (email) {\n    request.email = email;\n  }\n\n  if (password) {\n    request.password = password;\n  }\n\n  const response = await _logoutIfInvalidated(\n    user,\n    apiUpdateEmailPassword(auth, request)\n  );\n  await user._updateTokensIfNecessary(response, /* reload */ true);\n}\n", "/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AdditionalUserInfo, UserCredential } from '../../model/public_types';\nimport { IdTokenResponse, IdTokenResponseKind } from '../../model/id_token';\nimport { _parseToken } from './id_token_result';\nimport { UserCredentialInternal } from '../../model/user';\nimport { ProviderId } from '../../model/enums';\n\n/**\n * Parse the `AdditionalUserInfo` from the ID token response.\n *\n */\nexport function _fromIdTokenResponse(\n  idTokenResponse?: IdTokenResponse\n): AdditionalUserInfo | null {\n  if (!idTokenResponse) {\n    return null;\n  }\n  const { providerId } = idTokenResponse;\n  const profile = idTokenResponse.rawUserInfo\n    ? JSON.parse(idTokenResponse.rawUserInfo)\n    : {};\n  const isNewUser =\n    idTokenResponse.isNewUser ||\n    idTokenResponse.kind === IdTokenResponseKind.SignupNewUser;\n  if (!providerId && idTokenResponse?.idToken) {\n    const signInProvider = _parseToken(idTokenResponse.idToken)?.firebase?.[\n      'sign_in_provider'\n    ];\n    if (signInProvider) {\n      const filteredProviderId =\n        signInProvider !== ProviderId.ANONYMOUS &&\n        signInProvider !== ProviderId.CUSTOM\n          ? (signInProvider as ProviderId)\n          : null;\n      // Uses generic class in accordance with the legacy SDK.\n      return new GenericAdditionalUserInfo(isNewUser, filteredProviderId);\n    }\n  }\n  if (!providerId) {\n    return null;\n  }\n  switch (providerId) {\n    case ProviderId.FACEBOOK:\n      return new FacebookAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.GITHUB:\n      return new GithubAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.GOOGLE:\n      return new GoogleAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.TWITTER:\n      return new TwitterAdditionalUserInfo(\n        isNewUser,\n        profile,\n        idTokenResponse.screenName || null\n      );\n    case ProviderId.CUSTOM:\n    case ProviderId.ANONYMOUS:\n      return new GenericAdditionalUserInfo(isNewUser, null);\n    default:\n      return new GenericAdditionalUserInfo(isNewUser, providerId, profile);\n  }\n}\n\nclass GenericAdditionalUserInfo implements AdditionalUserInfo {\n  constructor(\n    readonly isNewUser: boolean,\n    readonly providerId: ProviderId | string | null,\n    readonly profile: Record<string, unknown> = {}\n  ) {}\n}\n\nclass FederatedAdditionalUserInfoWithUsername extends GenericAdditionalUserInfo {\n  constructor(\n    isNewUser: boolean,\n    providerId: ProviderId,\n    profile: Record<string, unknown>,\n    readonly username: string | null\n  ) {\n    super(isNewUser, providerId, profile);\n  }\n}\n\nclass FacebookAdditionalUserInfo extends GenericAdditionalUserInfo {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(isNewUser, ProviderId.FACEBOOK, profile);\n  }\n}\n\nclass GithubAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(\n      isNewUser,\n      ProviderId.GITHUB,\n      profile,\n      typeof profile?.login === 'string' ? profile?.login : null\n    );\n  }\n}\n\nclass GoogleAdditionalUserInfo extends GenericAdditionalUserInfo {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(isNewUser, ProviderId.GOOGLE, profile);\n  }\n}\n\nclass TwitterAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {\n  constructor(\n    isNewUser: boolean,\n    profile: Record<string, unknown>,\n    screenName: string | null\n  ) {\n    super(isNewUser, ProviderId.TWITTER, profile, screenName);\n  }\n}\n\n/**\n * Extracts provider specific {@link AdditionalUserInfo} for the given credential.\n *\n * @param userCredential - The user credential.\n *\n * @public\n */\nexport function getAdditionalUserInfo(\n  userCredential: UserCredential\n): AdditionalUserInfo | null {\n  const { user, _tokenResponse } = userCredential as UserCredentialInternal;\n  if (user.isAnonymous && !_tokenResponse) {\n    // Handle the special case where signInAnonymously() gets called twice.\n    // No network call is made so there's nothing to actually fill this in\n    return {\n      providerId: null,\n      isNewUser: false,\n      profile: null\n    };\n  }\n\n  return _fromIdTokenResponse(_tokenResponse);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getModularInstance } from '@firebase/util';\nimport {\n  Auth,\n  NextOrObserver,\n  Persistence,\n  User,\n  CompleteFn,\n  ErrorFn,\n  Unsubscribe,\n  PasswordValidationStatus\n} from '../model/public_types';\nimport { _initializeRecaptchaConfig } from '../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { _castAuth } from '../core/auth/auth_impl';\n\nexport {\n  debugErrorMap,\n  prodErrorMap,\n  AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as AuthErrorCodes\n} from './errors';\n\n// Non-optional auth methods.\n/**\n * Changes the type of persistence on the {@link Auth} instance for the currently saved\n * `Auth` session and applies this type of persistence for future sign-in requests, including\n * sign-in with redirect requests.\n *\n * @remarks\n * This makes it easy for a user signing in to specify whether their session should be\n * remembered or not. It also makes it easier to never persist the `Auth` state for applications\n * that are shared by other users or have sensitive data.\n *\n * This method does not work in a Node.js environment or with {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @example\n * ```javascript\n * setPersistence(auth, browserSessionPersistence);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param persistence - The {@link Persistence} to use.\n * @returns A `Promise` that resolves once the persistence change has completed\n *\n * @public\n */\nexport function setPersistence(\n  auth: Auth,\n  persistence: Persistence\n): Promise<void> {\n  return getModularInstance(auth).setPersistence(persistence);\n}\n\n/**\n * Loads the reCAPTCHA configuration into the `Auth` instance.\n *\n * @remarks\n * This will load the reCAPTCHA config, which indicates whether the reCAPTCHA\n * verification flow should be triggered for each auth provider, into the\n * current Auth session.\n *\n * If initializeRecaptchaConfig() is not invoked, the auth flow will always start\n * without reCAPTCHA verification. If the provider is configured to require reCAPTCHA\n * verification, the SDK will transparently load the reCAPTCHA config and restart the\n * auth flows.\n *\n * Thus, by calling this optional method, you will reduce the latency of future auth flows.\n * Loading the reCAPTCHA config early will also enhance the signal collected by reCAPTCHA.\n *\n * This method does not work in a Node.js environment.\n *\n * @example\n * ```javascript\n * initializeRecaptchaConfig(auth);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function initializeRecaptchaConfig(auth: Auth): Promise<void> {\n  return _initializeRecaptchaConfig(auth);\n}\n\n/**\n * Validates the password against the password policy configured for the project or tenant.\n *\n * @remarks\n * If no tenant ID is set on the `Auth` instance, then this method will use the password\n * policy configured for the project. Otherwise, this method will use the policy configured\n * for the tenant. If a password policy has not been configured, then the default policy\n * configured for all projects will be used.\n *\n * If an auth flow fails because a submitted password does not meet the password policy\n * requirements and this method has previously been called, then this method will use the\n * most recent policy available when called again.\n *\n * @example\n * ```javascript\n * validatePassword(auth, 'some-password');\n * ```\n *\n * @param auth The {@link Auth} instance.\n * @param password The password to validate.\n *\n * @public\n */\nexport async function validatePassword(\n  auth: Auth,\n  password: string\n): Promise<PasswordValidationStatus> {\n  const authInternal = _castAuth(auth);\n  return authInternal.validatePassword(password);\n}\n\n/**\n * Adds an observer for changes to the signed-in user's ID token.\n *\n * @remarks\n * This includes sign-in, sign-out, and token refresh events.\n * This will not be triggered automatically upon ID token expiration. Use {@link User.getIdToken} to refresh the ID token.\n *\n * @param auth - The {@link Auth} instance.\n * @param nextOrObserver - callback triggered on change.\n * @param error - Deprecated. This callback is never triggered. Errors\n * on signing in/out can be caught in promises returned from\n * sign-in/sign-out functions.\n * @param completed - Deprecated. This callback is never triggered.\n *\n * @public\n */\nexport function onIdTokenChanged(\n  auth: Auth,\n  nextOrObserver: NextOrObserver<User>,\n  error?: ErrorFn,\n  completed?: CompleteFn\n): Unsubscribe {\n  return getModularInstance(auth).onIdTokenChanged(\n    nextOrObserver,\n    error,\n    completed\n  );\n}\n/**\n * Adds a blocking callback that runs before an auth state change\n * sets a new user.\n *\n * @param auth - The {@link Auth} instance.\n * @param callback - callback triggered before new user value is set.\n *   If this throws, it blocks the user from being set.\n * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`\n *   callback throws, allowing you to undo any side effects.\n */\nexport function beforeAuthStateChanged(\n  auth: Auth,\n  callback: (user: User | null) => void | Promise<void>,\n  onAbort?: () => void\n): Unsubscribe {\n  return getModularInstance(auth).beforeAuthStateChanged(callback, onAbort);\n}\n/**\n * Adds an observer for changes to the user's sign-in state.\n *\n * @remarks\n * To keep the old behavior, see {@link onIdTokenChanged}.\n *\n * @param auth - The {@link Auth} instance.\n * @param nextOrObserver - callback triggered on change.\n * @param error - Deprecated. This callback is never triggered. Errors\n * on signing in/out can be caught in promises returned from\n * sign-in/sign-out functions.\n * @param completed - Deprecated. This callback is never triggered.\n *\n * @public\n */\nexport function onAuthStateChanged(\n  auth: Auth,\n  nextOrObserver: NextOrObserver<User>,\n  error?: ErrorFn,\n  completed?: CompleteFn\n): Unsubscribe {\n  return getModularInstance(auth).onAuthStateChanged(\n    nextOrObserver,\n    error,\n    completed\n  );\n}\n/**\n * Sets the current language to the default device/browser preference.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function useDeviceLanguage(auth: Auth): void {\n  getModularInstance(auth).useDeviceLanguage();\n}\n/**\n * Asynchronously sets the provided user as {@link Auth.currentUser} on the\n * {@link Auth} instance.\n *\n * @remarks\n * A new instance copy of the user provided will be made and set as currentUser.\n *\n * This will trigger {@link onAuthStateChanged} and {@link onIdTokenChanged} listeners\n * like other sign in methods.\n *\n * The operation fails with an error if the user to be updated belongs to a different Firebase\n * project.\n *\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n * @param user - The new {@link User}.\n *\n * @public\n */\nexport function updateCurrentUser(\n  auth: Auth,\n  user: User | null\n): Promise<void> {\n  return getModularInstance(auth).updateCurrentUser(user);\n}\n/**\n * Signs out the current user.\n *\n * @remarks\n * This method is not supported by {@link Auth} instances created with a\n * {@link @firebase/app#FirebaseServerApp}.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function signOut(auth: Auth): Promise<void> {\n  return getModularInstance(auth).signOut();\n}\n\n/**\n * Revokes the given access token. Currently only supports Apple OAuth access tokens.\n *\n * @param auth - The {@link Auth} instance.\n * @param token - The Apple OAuth access token.\n *\n * @public\n */\nexport function revokeAccessToken(auth: Auth, token: string): Promise<void> {\n  const authInternal = _castAuth(auth);\n  return authInternal.revokeAccessToken(token);\n}\n\nexport { initializeAuth } from './auth/initialize';\nexport { connectAuthEmulator } from './auth/emulator';\n\n// credentials\nexport { AuthCredential } from './credentials';\nexport { EmailAuthCredential } from './credentials/email';\nexport { OAuthCredential } from './credentials/oauth';\nexport { PhoneAuthCredential } from './credentials/phone';\n\n// persistence\nexport { inMemoryPersistence } from './persistence/in_memory';\n\n// providers\nexport { EmailAuthProvider } from './providers/email';\nexport { FacebookAuthProvider } from './providers/facebook';\nexport { CustomParameters } from './providers/federated';\nexport { GoogleAuthProvider } from './providers/google';\nexport { GithubAuthProvider } from './providers/github';\nexport { OAuthProvider, OAuthCredentialOptions } from './providers/oauth';\nexport { SAMLAuthProvider } from './providers/saml';\nexport { TwitterAuthProvider } from './providers/twitter';\n\n// strategies\nexport { signInAnonymously } from './strategies/anonymous';\nexport {\n  signInWithCredential,\n  linkWithCredential,\n  reauthenticateWithCredential\n} from './strategies/credential';\nexport { signInWithCustomToken } from './strategies/custom_token';\nexport {\n  sendPasswordResetEmail,\n  confirmPasswordReset,\n  applyActionCode,\n  checkActionCode,\n  verifyPasswordResetCode,\n  createUserWithEmailAndPassword,\n  signInWithEmailAndPassword\n} from './strategies/email_and_password';\nexport {\n  sendSignInLinkToEmail,\n  isSignInWithEmailLink,\n  signInWithEmailLink\n} from './strategies/email_link';\nexport {\n  fetchSignInMethodsForEmail,\n  sendEmailVerification,\n  verifyBeforeUpdateEmail\n} from './strategies/email';\n\n// core\nexport { ActionCodeURL, parseActionCodeURL } from './action_code_url';\n\n// user\nexport {\n  updateProfile,\n  updateEmail,\n  updatePassword\n} from './user/account_info';\nexport { getIdToken, getIdTokenResult } from './user/id_token_result';\nexport { unlink } from './user/link_unlink';\nexport { getAdditionalUserInfo } from './user/additional_user_info';\n\n// Non-optional user methods.\nexport { reload } from './user/reload';\n/**\n * Deletes and signs out the user.\n *\n * @remarks\n * Important: this is a security-sensitive operation that requires the user to have recently\n * signed in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n *\n * @public\n */\nexport async function deleteUser(user: User): Promise<void> {\n  return getModularInstance(user).delete();\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserInternal } from '../model/user';\nimport { MultiFactorSession } from '../model/public_types';\n\nexport const enum MultiFactorSessionType {\n  ENROLL = 'enroll',\n  SIGN_IN = 'signin'\n}\n\ninterface SerializedMultiFactorSession {\n  multiFactorSession: {\n    idToken?: string;\n    pendingCredential?: string;\n  };\n}\n\nexport class MultiFactorSessionImpl implements MultiFactorSession {\n  private constructor(\n    readonly type: MultiFactorSessionType,\n    readonly credential: string,\n    readonly user?: UserInternal\n  ) {}\n\n  static _fromIdtoken(\n    idToken: string,\n    user?: UserInternal\n  ): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(\n      MultiFactorSessionType.ENROLL,\n      idToken,\n      user\n    );\n  }\n\n  static _fromMfaPendingCredential(\n    mfaPendingCredential: string\n  ): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(\n      MultiFactorSessionType.SIGN_IN,\n      mfaPendingCredential\n    );\n  }\n\n  toJSON(): SerializedMultiFactorSession {\n    const key =\n      this.type === MultiFactorSessionType.ENROLL\n        ? 'idToken'\n        : 'pendingCredential';\n    return {\n      multiFactorSession: {\n        [key]: this.credential\n      }\n    };\n  }\n\n  static fromJSON(\n    obj: Partial<SerializedMultiFactorSession>\n  ): MultiFactorSessionImpl | null {\n    if (obj?.multiFactorSession) {\n      if (obj.multiFactorSession?.pendingCredential) {\n        return MultiFactorSessionImpl._fromMfaPendingCredential(\n          obj.multiFactorSession.pendingCredential\n        );\n      } else if (obj.multiFactorSession?.idToken) {\n        return MultiFactorSessionImpl._fromIdtoken(\n          obj.multiFactorSession.idToken\n        );\n      }\n    }\n    return null;\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Auth,\n  MultiFactorResolver,\n  UserCredential,\n  MultiFactorError\n} from '../model/public_types';\n\nimport { _castAuth } from '../core/auth/auth_impl';\nimport { AuthErrorCode } from '../core/errors';\nimport { UserCredentialImpl } from '../core/user/user_credential_impl';\nimport { _assert, _fail } from '../core/util/assert';\nimport { UserCredentialInternal } from '../model/user';\nimport { MultiFactorAssertionImpl } from './mfa_assertion';\nimport { MultiFactorError as MultiFactorErrorInternal } from './mfa_error';\nimport { MultiFactorInfoImpl } from './mfa_info';\nimport { MultiFactorSessionImpl } from './mfa_session';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../model/enums';\n\nexport class MultiFactorResolverImpl implements MultiFactorResolver {\n  private constructor(\n    readonly session: MultiFactorSessionImpl,\n    readonly hints: MultiFactorInfoImpl[],\n    private readonly signInResolver: (\n      assertion: MultiFactorAssertionImpl\n    ) => Promise<UserCredentialInternal>\n  ) {}\n\n  /** @internal */\n  static _fromError(\n    authExtern: Auth,\n    error: MultiFactorErrorInternal\n  ): MultiFactorResolverImpl {\n    const auth = _castAuth(authExtern);\n    const serverResponse = error.customData._serverResponse;\n    const hints = (serverResponse.mfaInfo || []).map(enrollment =>\n      MultiFactorInfoImpl._fromServerResponse(auth, enrollment)\n    );\n\n    _assert(\n      serverResponse.mfaPendingCredential,\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const session = MultiFactorSessionImpl._fromMfaPendingCredential(\n      serverResponse.mfaPendingCredential\n    );\n\n    return new MultiFactorResolverImpl(\n      session,\n      hints,\n      async (\n        assertion: MultiFactorAssertionImpl\n      ): Promise<UserCredentialInternal> => {\n        const mfaResponse = await assertion._process(auth, session);\n        // Clear out the unneeded fields from the old login response\n        delete serverResponse.mfaInfo;\n        delete serverResponse.mfaPendingCredential;\n\n        // Use in the new token & refresh token in the old response\n        const idTokenResponse = {\n          ...serverResponse,\n          idToken: mfaResponse.idToken,\n          refreshToken: mfaResponse.refreshToken\n        };\n\n        // TODO: we should collapse this switch statement into UserCredentialImpl._forOperation and have it support the SIGN_IN case\n        switch (error.operationType) {\n          case OperationType.SIGN_IN:\n            const userCredential =\n              await UserCredentialImpl._fromIdTokenResponse(\n                auth,\n                error.operationType,\n                idTokenResponse\n              );\n            await auth._updateCurrentUser(userCredential.user);\n            return userCredential;\n          case OperationType.REAUTHENTICATE:\n            _assert(error.user, auth, AuthErrorCode.INTERNAL_ERROR);\n            return UserCredentialImpl._forOperation(\n              error.user,\n              error.operationType,\n              idTokenResponse\n            );\n          default:\n            _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n        }\n      }\n    );\n  }\n\n  async resolveSignIn(\n    assertionExtern: MultiFactorAssertionImpl\n  ): Promise<UserCredential> {\n    const assertion = assertionExtern as MultiFactorAssertionImpl;\n    return this.signInResolver(assertion);\n  }\n}\n\n/**\n * Provides a {@link MultiFactorResolver} suitable for completion of a\n * multi-factor flow.\n *\n * @param auth - The {@link Auth} instance.\n * @param error - The {@link MultiFactorError} raised during a sign-in, or\n * reauthentication operation.\n *\n * @public\n */\nexport function getMultiFactorResolver(\n  auth: Auth,\n  error: MultiFactorError\n): MultiFactorResolver {\n  const authModular = getModularInstance(auth);\n  const errorInternal = error as MultiFactorErrorInternal;\n  _assert(\n    error.customData.operationType,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\n  _assert(\n    errorInternal.customData._serverResponse?.mfaPendingCredential,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\n\n  return MultiFactorResolverImpl._fromError(authModular, errorInternal);\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { SignInWithPhoneNumberRequest } from '../authentication/sms';\nimport { FinalizeMfaResponse } from '../authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\n\n/**\n * MFA Info as returned by the API.\n */\ninterface BaseMfaEnrollment {\n  mfaEnrollmentId: string;\n  enrolledAt: number;\n  displayName?: string;\n}\n\n/**\n * An MFA provided by SMS verification.\n */\nexport interface PhoneMfaEnrollment extends BaseMfaEnrollment {\n  phoneInfo: string;\n}\n\n/**\n * An MFA provided by TOTP (Time-based One Time Password).\n */\nexport interface TotpMfaEnrollment extends BaseMfaEnrollment {}\n\n/**\n * MfaEnrollment can be any subtype of BaseMfaEnrollment, currently only PhoneMfaEnrollment and TotpMfaEnrollment are supported.\n */\nexport type MfaEnrollment = PhoneMfaEnrollment | TotpMfaEnrollment;\n\nexport interface StartPhoneMfaEnrollmentRequest {\n  idToken: string;\n  phoneEnrollmentInfo: {\n    phoneNumber: string;\n    // reCAPTCHA v2 token\n    recaptchaToken?: string;\n    // reCAPTCHA Enterprise token\n    captchaResponse?: string;\n    clientType?: RecaptchaClientType;\n    recaptchaVersion?: RecaptchaVersion;\n  };\n  tenantId?: string;\n}\n\nexport interface StartPhoneMfaEnrollmentResponse {\n  phoneSessionInfo: {\n    sessionInfo: string;\n  };\n}\n\nexport function startEnrollPhoneMfa(\n  auth: AuthInternal,\n  request: StartPhoneMfaEnrollmentRequest\n): Promise<StartPhoneMfaEnrollmentResponse> {\n  return _performApiRequest<\n    StartPhoneMfaEnrollmentRequest,\n    StartPhoneMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface FinalizePhoneMfaEnrollmentRequest {\n  idToken: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  displayName?: string | null;\n  tenantId?: string;\n}\n\nexport interface FinalizePhoneMfaEnrollmentResponse\n  extends FinalizeMfaResponse {}\n\nexport function finalizeEnrollPhoneMfa(\n  auth: AuthInternal,\n  request: FinalizePhoneMfaEnrollmentRequest\n): Promise<FinalizePhoneMfaEnrollmentResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaEnrollmentRequest,\n    FinalizePhoneMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\nexport interface StartTotpMfaEnrollmentRequest {\n  idToken: string;\n  totpEnrollmentInfo: {};\n  tenantId?: string;\n}\n\nexport interface StartTotpMfaEnrollmentResponse {\n  totpSessionInfo: {\n    sharedSecretKey: string;\n    verificationCodeLength: number;\n    hashingAlgorithm: string;\n    periodSec: number;\n    sessionInfo: string;\n    finalizeEnrollmentTime: number;\n  };\n}\n\nexport function startEnrollTotpMfa(\n  auth: AuthInternal,\n  request: StartTotpMfaEnrollmentRequest\n): Promise<StartTotpMfaEnrollmentResponse> {\n  return _performApiRequest<\n    StartTotpMfaEnrollmentRequest,\n    StartTotpMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface TotpVerificationInfo {\n  sessionInfo: string;\n  verificationCode: string;\n}\nexport interface FinalizeTotpMfaEnrollmentRequest {\n  idToken: string;\n  totpVerificationInfo: TotpVerificationInfo;\n  displayName?: string | null;\n  tenantId?: string;\n}\n\nexport interface FinalizeTotpMfaEnrollmentResponse\n  extends FinalizeMfaResponse {}\n\nexport function finalizeEnrollTotpMfa(\n  auth: AuthInternal,\n  request: FinalizeTotpMfaEnrollmentRequest\n): Promise<FinalizeTotpMfaEnrollmentResponse> {\n  return _performApiRequest<\n    FinalizeTotpMfaEnrollmentRequest,\n    FinalizeTotpMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface WithdrawMfaRequest {\n  idToken: string;\n  mfaEnrollmentId: string;\n  tenantId?: string;\n}\n\nexport interface WithdrawMfaResponse extends FinalizeMfaResponse {}\n\nexport function withdrawMfa(\n  auth: AuthInternal,\n  request: WithdrawMfaRequest\n): Promise<WithdrawMfaResponse> {\n  return _performApiRequest<WithdrawMfaRequest, WithdrawMfaResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.WITHDRAW_MFA,\n    _addTidIfNecessary(auth, request)\n  );\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  MultiFactorAssertion,\n  MultiFactorInfo,\n  MultiFactorSession,\n  MultiFactorUser,\n  User\n} from '../model/public_types';\n\nimport { withdrawMfa } from '../api/account_management/mfa';\nimport { _logoutIfInvalidated } from '../core/user/invalidation';\nimport { UserInternal } from '../model/user';\nimport { MultiFactorAssertionImpl } from './mfa_assertion';\nimport { MultiFactorInfoImpl } from './mfa_info';\nimport { MultiFactorSessionImpl } from './mfa_session';\nimport { getModularInstance } from '@firebase/util';\n\nexport class MultiFactorUserImpl implements MultiFactorUser {\n  enrolledFactors: MultiFactorInfo[] = [];\n\n  private constructor(readonly user: UserInternal) {\n    user._onReload(userInfo => {\n      if (userInfo.mfaInfo) {\n        this.enrolledFactors = userInfo.mfaInfo.map(enrollment =>\n          MultiFactorInfoImpl._fromServerResponse(user.auth, enrollment)\n        );\n      }\n    });\n  }\n\n  static _fromUser(user: UserInternal): MultiFactorUserImpl {\n    return new MultiFactorUserImpl(user);\n  }\n\n  async getSession(): Promise<MultiFactorSession> {\n    return MultiFactorSessionImpl._fromIdtoken(\n      await this.user.getIdToken(),\n      this.user\n    );\n  }\n\n  async enroll(\n    assertionExtern: MultiFactorAssertion,\n    displayName?: string | null\n  ): Promise<void> {\n    const assertion = assertionExtern as MultiFactorAssertionImpl;\n    const session = (await this.getSession()) as MultiFactorSessionImpl;\n    const finalizeMfaResponse = await _logoutIfInvalidated(\n      this.user,\n      assertion._process(this.user.auth, session, displayName)\n    );\n    // New tokens will be issued after enrollment of the new second factors.\n    // They need to be updated on the user.\n    await this.user._updateTokensIfNecessary(finalizeMfaResponse);\n    // The user needs to be reloaded to get the new multi-factor information\n    // from server. USER_RELOADED event will be triggered and `enrolledFactors`\n    // will be updated.\n    return this.user.reload();\n  }\n\n  async unenroll(infoOrUid: MultiFactorInfo | string): Promise<void> {\n    const mfaEnrollmentId =\n      typeof infoOrUid === 'string' ? infoOrUid : infoOrUid.uid;\n    const idToken = await this.user.getIdToken();\n    try {\n      const idTokenResponse = await _logoutIfInvalidated(\n        this.user,\n        withdrawMfa(this.user.auth, {\n          idToken,\n          mfaEnrollmentId\n        })\n      );\n      // Remove the second factor from the user's list.\n      this.enrolledFactors = this.enrolledFactors.filter(\n        ({ uid }) => uid !== mfaEnrollmentId\n      );\n      // Depending on whether the backend decided to revoke the user's session,\n      // the tokenResponse may be empty. If the tokens were not updated (and they\n      // are now invalid), reloading the user will discover this and invalidate\n      // the user's state accordingly.\n      await this.user._updateTokensIfNecessary(idTokenResponse);\n      await this.user.reload();\n    } catch (e) {\n      throw e;\n    }\n  }\n}\n\nconst multiFactorUserCache = new WeakMap<User, MultiFactorUser>();\n\n/**\n * The {@link MultiFactorUser} corresponding to the user.\n *\n * @remarks\n * This is used to access all multi-factor properties and operations related to the user.\n *\n * @param user - The user.\n *\n * @public\n */\nexport function multiFactor(user: User): MultiFactorUser {\n  const userModular = getModularInstance(user);\n  if (!multiFactorUserCache.has(userModular)) {\n    multiFactorUserCache.set(\n      userModular,\n      MultiFactorUserImpl._fromUser(userModular as UserInternal)\n    );\n  }\n  return multiFactorUserCache.get(userModular)!;\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Unsubscribe } from '@firebase/util';\nimport { FirebaseAuthInternal } from '@firebase/auth-interop-types';\n\nimport { AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { _assert } from '../util/assert';\nimport { AuthErrorCode } from '../errors';\n\ninterface TokenListener {\n  (tok: string | null): unknown;\n}\n\nexport class AuthInterop implements FirebaseAuthInternal {\n  private readonly internalListeners: Map<TokenListener, Unsubscribe> =\n    new Map();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  getUid(): string | null {\n    this.assertAuthConfigured();\n    return this.auth.currentUser?.uid || null;\n  }\n\n  async getToken(\n    forceRefresh?: boolean\n  ): Promise<{ accessToken: string } | null> {\n    this.assertAuthConfigured();\n    await this.auth._initializationPromise;\n    if (!this.auth.currentUser) {\n      return null;\n    }\n\n    const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);\n    return { accessToken };\n  }\n\n  addAuthTokenListener(listener: TokenListener): void {\n    this.assertAuthConfigured();\n    if (this.internalListeners.has(listener)) {\n      return;\n    }\n\n    const unsubscribe = this.auth.onIdTokenChanged(user => {\n      listener(\n        (user as UserInternal | null)?.stsTokenManager.accessToken || null\n      );\n    });\n    this.internalListeners.set(listener, unsubscribe);\n    this.updateProactiveRefresh();\n  }\n\n  removeAuthTokenListener(listener: TokenListener): void {\n    this.assertAuthConfigured();\n    const unsubscribe = this.internalListeners.get(listener);\n    if (!unsubscribe) {\n      return;\n    }\n\n    this.internalListeners.delete(listener);\n    unsubscribe();\n    this.updateProactiveRefresh();\n  }\n\n  private assertAuthConfigured(): void {\n    _assert(\n      this.auth._initializationPromise,\n      AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH\n    );\n  }\n\n  private updateProactiveRefresh(): void {\n    if (this.internalListeners.size > 0) {\n      this.auth._startProactiveRefresh();\n    } else {\n      this.auth._stopProactiveRefresh();\n    }\n  }\n}\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _registerComponent, registerVersion } from '@firebase/app';\nimport {\n  Component,\n  ComponentType,\n  InstantiationMode\n} from '@firebase/component';\n\nimport { name, version } from '../../../package.json';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _getClientVersion, ClientPlatform } from '../util/version';\nimport { _castAuth, AuthImpl, DefaultConfig } from './auth_impl';\nimport { AuthInterop } from './firebase_internal';\nimport { ConfigInternal } from '../../model/auth';\nimport { Dependencies } from '../../model/public_types';\nimport { _initializeAuthInstance } from './initialize';\n\nexport const enum _ComponentName {\n  AUTH = 'auth',\n  AUTH_INTERNAL = 'auth-internal'\n}\n\nfunction getVersionForPlatform(\n  clientPlatform: ClientPlatform\n): string | undefined {\n  switch (clientPlatform) {\n    case ClientPlatform.NODE:\n      return 'node';\n    case ClientPlatform.REACT_NATIVE:\n      return 'rn';\n    case ClientPlatform.WORKER:\n      return 'webworker';\n    case ClientPlatform.CORDOVA:\n      return 'cordova';\n    case ClientPlatform.WEB_EXTENSION:\n      return 'web-extension';\n    default:\n      return undefined;\n  }\n}\n\n/** @internal */\nexport function registerAuth(clientPlatform: ClientPlatform): void {\n  _registerComponent(\n    new Component(\n      _ComponentName.AUTH,\n      (container, { options: deps }: { options?: Dependencies }) => {\n        const app = container.getProvider('app').getImmediate()!;\n        const heartbeatServiceProvider =\n          container.getProvider<'heartbeat'>('heartbeat');\n        const appCheckServiceProvider =\n          container.getProvider<'app-check-internal'>('app-check-internal');\n        const { apiKey, authDomain } = app.options;\n\n        _assert(\n          apiKey && !apiKey.includes(':'),\n          AuthErrorCode.INVALID_API_KEY,\n          { appName: app.name }\n        );\n\n        const config: ConfigInternal = {\n          apiKey,\n          authDomain,\n          clientPlatform,\n          apiHost: DefaultConfig.API_HOST,\n          tokenApiHost: DefaultConfig.TOKEN_API_HOST,\n          apiScheme: DefaultConfig.API_SCHEME,\n          sdkClientVersion: _getClientVersion(clientPlatform)\n        };\n\n        const authInstance = new AuthImpl(\n          app,\n          heartbeatServiceProvider,\n          appCheckServiceProvider,\n          config\n        );\n        _initializeAuthInstance(authInstance, deps);\n\n        return authInstance;\n      },\n      ComponentType.PUBLIC\n    )\n      /**\n       * Auth can only be initialized by explicitly calling getAuth() or initializeAuth()\n       * For why we do this, See go/firebase-next-auth-init\n       */\n      .setInstantiationMode(InstantiationMode.EXPLICIT)\n      /**\n       * Because all firebase products that depend on auth depend on auth-internal directly,\n       * we need to initialize auth-internal after auth is initialized to make it available to other firebase products.\n       */\n      .setInstanceCreatedCallback(\n        (container, _instanceIdentifier, _instance) => {\n          const authInternalProvider = container.getProvider(\n            _ComponentName.AUTH_INTERNAL\n          );\n          authInternalProvider.initialize();\n        }\n      )\n  );\n\n  _registerComponent(\n    new Component(\n      _ComponentName.AUTH_INTERNAL,\n      container => {\n        const auth = _castAuth(\n          container.getProvider(_ComponentName.AUTH).getImmediate()!\n        );\n        return (auth => new AuthInterop(auth))(auth);\n      },\n      ComponentType.PRIVATE\n    ).setInstantiationMode(InstantiationMode.EXPLICIT)\n  );\n\n  registerVersion(name, version, getVersionForPlatform(clientPlatform));\n  // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n}\n", "/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../core/errors';\nimport { _createError } from '../core/util/assert';\n\nimport { FirebaseApp, getApp, _getProvider } from '@firebase/app';\nimport { Auth } from '../model/public_types';\n\nimport { initializeAuth, inMemoryPersistence, connectAuthEmulator } from '..';\nimport { registerAuth } from '../core/auth/register';\nimport { ClientPlatform } from '../core/util/version';\nimport { AuthImpl } from '../core/auth/auth_impl';\n\nimport { FetchProvider } from '../core/util/fetch_provider';\nimport { getDefaultEmulatorHost } from '@firebase/util';\n\n// Initialize the fetch polyfill, the types are slightly off so just cast and hope for the best\nFetchProvider.initialize(fetch, Headers, Response);\n\n// First, we set up the various platform-specific features for Node (register\n// the version and declare the Node getAuth function)\n\nexport function getAuth(app: FirebaseApp = getApp()): Auth {\n  const provider = _getProvider(app, 'auth');\n\n  if (provider.isInitialized()) {\n    return provider.getImmediate();\n  }\n\n  const auth = initializeAuth(app);\n\n  const authEmulatorHost = getDefaultEmulatorHost('auth');\n  if (authEmulatorHost) {\n    connectAuthEmulator(auth, `http://${authEmulatorHost}`);\n  }\n\n  return auth;\n}\n\nregisterAuth(ClientPlatform.NODE);\n\n// The rest of this file contains no-ops and errors for browser-specific\n// methods. We keep the browser and Node entry points the same, but features\n// that only work in browsers are set to either do nothing (setPersistence) or\n// to reject with an auth/operation-not-supported-in-this-environment error.\n// The below exports are pulled into the main entry point by a rollup alias\n// plugin (overwriting the default browser imports).\n\n/** auth/operation-not-supported-in-this-environment */\nconst NOT_AVAILABLE_ERROR = _createError(AuthErrorCode.OPERATION_NOT_SUPPORTED);\n\n/** Reject with auth/operation-not-supported-in-this-environment */\nasync function fail(): Promise<void> {\n  throw NOT_AVAILABLE_ERROR;\n}\n\n/**\n * A class which will throw with\n * auth/operation-not-supported-in-this-environment if instantiated\n */\nclass FailClass {\n  constructor() {\n    throw NOT_AVAILABLE_ERROR;\n  }\n}\n\nexport const browserLocalPersistence = inMemoryPersistence;\nexport const browserSessionPersistence = inMemoryPersistence;\nexport const browserCookiePersistence = inMemoryPersistence;\nexport const indexedDBLocalPersistence = inMemoryPersistence;\nexport const browserPopupRedirectResolver = NOT_AVAILABLE_ERROR;\nexport const PhoneAuthProvider = FailClass;\nexport const signInWithPhoneNumber = fail;\nexport const linkWithPhoneNumber = fail;\nexport const reauthenticateWithPhoneNumber = fail;\nexport const updatePhoneNumber = fail;\nexport const signInWithPopup = fail;\nexport const linkWithPopup = fail;\nexport const reauthenticateWithPopup = fail;\nexport const signInWithRedirect = fail;\nexport const linkWithRedirect = fail;\nexport const reauthenticateWithRedirect = fail;\nexport const getRedirectResult = fail;\nexport const RecaptchaVerifier = FailClass;\nexport const initializeRecaptchaConfig = fail;\nexport class PhoneMultiFactorGenerator {\n  static assertion(): unknown {\n    throw NOT_AVAILABLE_ERROR;\n  }\n}\n\n// Set persistence should no-op instead of fail. Changing the prototype will\n// make sure both setPersistence(auth, persistence) and\n// auth.setPersistence(persistence) are covered.\nAuthImpl.prototype.setPersistence = async (): Promise<void> => {};\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performApiRequest,\n  Endpoint,\n  HttpMethod,\n  RecaptchaClientType,\n  RecaptchaVersion,\n  _addTidIfNecessary\n} from '../index';\nimport { Auth } from '../../model/public_types';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { MfaEnrollment } from '../account_management/mfa';\nimport { SignInWithIdpResponse } from './idp';\nimport {\n  SignInWithPhoneNumberRequest,\n  SignInWithPhoneNumberResponse\n} from './sms';\n\nexport interface FinalizeMfaResponse {\n  idToken: string;\n  refreshToken: string;\n}\n\n/**\n * @internal\n */\nexport interface IdTokenMfaResponse extends IdTokenResponse {\n  mfaPendingCredential?: string;\n  mfaInfo?: MfaEnrollment[];\n}\n\nexport interface StartPhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  mfaEnrollmentId: string;\n  phoneSignInInfo: {\n    // reCAPTCHA v2 token\n    recaptchaToken?: string;\n    // reCAPTCHA Enterprise token\n    captchaResponse?: string;\n    clientType?: RecaptchaClientType;\n    recaptchaVersion?: RecaptchaVersion;\n  };\n  tenantId?: string;\n}\n\nexport interface StartPhoneMfaSignInResponse {\n  phoneResponseInfo: {\n    sessionInfo: string;\n  };\n}\n\nexport function startSignInPhoneMfa(\n  auth: Auth,\n  request: StartPhoneMfaSignInRequest\n): Promise<StartPhoneMfaSignInResponse> {\n  return _performApiRequest<\n    StartPhoneMfaSignInRequest,\n    StartPhoneMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface FinalizePhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  tenantId?: string;\n}\n\n// TOTP MFA Sign in only has a finalize phase. Phone MFA has a start phase to initiate sending an\n// SMS and a finalize phase to complete sign in. With TOTP, the user already has the OTP in the\n// TOTP/Authenticator app.\nexport interface FinalizeTotpMfaSignInRequest {\n  mfaPendingCredential: string;\n  totpVerificationInfo: { verificationCode: string };\n  tenantId?: string;\n  mfaEnrollmentId: string;\n}\n\nexport interface FinalizePhoneMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport interface FinalizeTotpMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport function finalizeSignInPhoneMfa(\n  auth: Auth,\n  request: FinalizePhoneMfaSignInRequest\n): Promise<FinalizePhoneMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaSignInRequest,\n    FinalizePhoneMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport function finalizeSignInTotpMfa(\n  auth: Auth,\n  request: FinalizeTotpMfaSignInRequest\n): Promise<FinalizeTotpMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizeTotpMfaSignInRequest,\n    FinalizeTotpMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\n/**\n * @internal\n */\nexport type PhoneOrOauthTokenResponse =\n  | SignInWithPhoneNumberResponse\n  | SignInWithIdpResponse\n  | IdTokenResponse;\n", "/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { FactorId, MultiFactorAssertion } from '../model/public_types';\nimport { debugFail } from '../core/util/assert';\nimport { MultiFactorSessionImpl, MultiFactorSessionType } from './mfa_session';\nimport { FinalizeMfaResponse } from '../api/authentication/mfa';\nimport { AuthInternal } from '../model/auth';\n\nexport abstract class MultiFactorAssertionImpl implements MultiFactorAssertion {\n  protected constructor(readonly factorId: FactorId) {}\n\n  _process(\n    auth: AuthInternal,\n    session: MultiFactorSessionImpl,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse> {\n    switch (session.type) {\n      case MultiFactorSessionType.ENROLL:\n        return this._finalizeEnroll(auth, session.credential, displayName);\n      case MultiFactorSessionType.SIGN_IN:\n        return this._finalizeSignIn(auth, session.credential);\n      default:\n        return debugFail('unexpected MultiFactorSessionType');\n    }\n  }\n\n  abstract _finalizeEnroll(\n    auth: AuthInternal,\n    idToken: string,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse>;\n  abstract _finalizeSignIn(\n    auth: AuthInternal,\n    mfaPendingCredential: string\n  ): Promise<FinalizeMfaResponse>;\n}\n", "/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  TotpMultiFactorAssertion,\n  MultiFactorSession,\n  FactorId\n} from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  finalizeEnrollTotpMfa,\n  startEnrollTotpMfa,\n  StartTotpMfaEnrollmentResponse,\n  TotpVerificationInfo\n} from '../../api/account_management/mfa';\nimport {\n  FinalizeMfaResponse,\n  finalizeSignInTotpMfa\n} from '../../api/authentication/mfa';\nimport { MultiFactorAssertionImpl } from '../../mfa/mfa_assertion';\nimport { MultiFactorSessionImpl } from '../mfa_session';\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\n\n/**\n * Provider for generating a {@link TotpMultiFactorAssertion}.\n *\n * @public\n */\nexport class TotpMultiFactorGenerator {\n  /**\n   * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of\n   * the TOTP (time-based one-time password) second factor.\n   * This assertion is used to complete enrollment in TOTP second factor.\n   *\n   * @param secret A {@link TotpSecret} containing the shared secret key and other TOTP parameters.\n   * @param oneTimePassword One-time password from TOTP App.\n   * @returns A {@link TotpMultiFactorAssertion} which can be used with\n   * {@link MultiFactorUser.enroll}.\n   */\n  static assertionForEnrollment(\n    secret: TotpSecret,\n    oneTimePassword: string\n  ): TotpMultiFactorAssertion {\n    return TotpMultiFactorAssertionImpl._fromSecret(secret, oneTimePassword);\n  }\n\n  /**\n   * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of the TOTP second factor.\n   * This assertion is used to complete signIn with TOTP as the second factor.\n   *\n   * @param enrollmentId identifies the enrolled TOTP second factor.\n   * @param oneTimePassword One-time password from TOTP App.\n   * @returns A {@link TotpMultiFactorAssertion} which can be used with\n   * {@link MultiFactorResolver.resolveSignIn}.\n   */\n  static assertionForSignIn(\n    enrollmentId: string,\n    oneTimePassword: string\n  ): TotpMultiFactorAssertion {\n    return TotpMultiFactorAssertionImpl._fromEnrollmentId(\n      enrollmentId,\n      oneTimePassword\n    );\n  }\n\n  /**\n   * Returns a promise to {@link TotpSecret} which contains the TOTP shared secret key and other parameters.\n   * Creates a TOTP secret as part of enrolling a TOTP second factor.\n   * Used for generating a QR code URL or inputting into a TOTP app.\n   * This method uses the auth instance corresponding to the user in the multiFactorSession.\n   *\n   * @param session The {@link MultiFactorSession} that the user is part of.\n   * @returns A promise to {@link TotpSecret}.\n   */\n  static async generateSecret(\n    session: MultiFactorSession\n  ): Promise<TotpSecret> {\n    const mfaSession = session as MultiFactorSessionImpl;\n    _assert(\n      typeof mfaSession.user?.auth !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const response = await startEnrollTotpMfa(mfaSession.user.auth, {\n      idToken: mfaSession.credential,\n      totpEnrollmentInfo: {}\n    });\n    return TotpSecret._fromStartTotpMfaEnrollmentResponse(\n      response,\n      mfaSession.user.auth\n    );\n  }\n\n  /**\n   * The identifier of the TOTP second factor: `totp`.\n   */\n  static FACTOR_ID: 'totp' = FactorId.TOTP;\n}\n\nexport class TotpMultiFactorAssertionImpl\n  extends MultiFactorAssertionImpl\n  implements TotpMultiFactorAssertion\n{\n  constructor(\n    readonly otp: string,\n    readonly enrollmentId?: string,\n    readonly secret?: TotpSecret\n  ) {\n    super(FactorId.TOTP);\n  }\n\n  /** @internal */\n  static _fromSecret(\n    secret: TotpSecret,\n    otp: string\n  ): TotpMultiFactorAssertionImpl {\n    return new TotpMultiFactorAssertionImpl(otp, undefined, secret);\n  }\n\n  /** @internal */\n  static _fromEnrollmentId(\n    enrollmentId: string,\n    otp: string\n  ): TotpMultiFactorAssertionImpl {\n    return new TotpMultiFactorAssertionImpl(otp, enrollmentId);\n  }\n\n  /** @internal */\n  async _finalizeEnroll(\n    auth: AuthInternal,\n    idToken: string,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse> {\n    _assert(\n      typeof this.secret !== 'undefined',\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    return finalizeEnrollTotpMfa(auth, {\n      idToken,\n      displayName,\n      totpVerificationInfo: this.secret._makeTotpVerificationInfo(this.otp)\n    });\n  }\n\n  /** @internal */\n  async _finalizeSignIn(\n    auth: AuthInternal,\n    mfaPendingCredential: string\n  ): Promise<FinalizeMfaResponse> {\n    _assert(\n      this.enrollmentId !== undefined && this.otp !== undefined,\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    const totpVerificationInfo = { verificationCode: this.otp };\n    return finalizeSignInTotpMfa(auth, {\n      mfaPendingCredential,\n      mfaEnrollmentId: this.enrollmentId,\n      totpVerificationInfo\n    });\n  }\n}\n\n/**\n * Provider for generating a {@link TotpMultiFactorAssertion}.\n *\n * Stores the shared secret key and other parameters to generate time-based OTPs.\n * Implements methods to retrieve the shared secret key and generate a QR code URL.\n * @public\n */\nexport class TotpSecret {\n  /**\n   * Shared secret key/seed used for enrolling in TOTP MFA and generating OTPs.\n   */\n  readonly secretKey: string;\n  /**\n   * Hashing algorithm used.\n   */\n  readonly hashingAlgorithm: string;\n  /**\n   * Length of the one-time passwords to be generated.\n   */\n  readonly codeLength: number;\n  /**\n   * The interval (in seconds) when the OTP codes should change.\n   */\n  readonly codeIntervalSeconds: number;\n  /**\n   * The timestamp (UTC string) by which TOTP enrollment should be completed.\n   */\n  // This can be used by callers to show a countdown of when to enter OTP code by.\n  readonly enrollmentCompletionDeadline: string;\n\n  // The public members are declared outside the constructor so the docs can be generated.\n  private constructor(\n    secretKey: string,\n    hashingAlgorithm: string,\n    codeLength: number,\n    codeIntervalSeconds: number,\n    enrollmentCompletionDeadline: string,\n    private readonly sessionInfo: string,\n    private readonly auth: AuthInternal\n  ) {\n    this.secretKey = secretKey;\n    this.hashingAlgorithm = hashingAlgorithm;\n    this.codeLength = codeLength;\n    this.codeIntervalSeconds = codeIntervalSeconds;\n    this.enrollmentCompletionDeadline = enrollmentCompletionDeadline;\n  }\n\n  /** @internal */\n  static _fromStartTotpMfaEnrollmentResponse(\n    response: StartTotpMfaEnrollmentResponse,\n    auth: AuthInternal\n  ): TotpSecret {\n    return new TotpSecret(\n      response.totpSessionInfo.sharedSecretKey,\n      response.totpSessionInfo.hashingAlgorithm,\n      response.totpSessionInfo.verificationCodeLength,\n      response.totpSessionInfo.periodSec,\n      new Date(response.totpSessionInfo.finalizeEnrollmentTime).toUTCString(),\n      response.totpSessionInfo.sessionInfo,\n      auth\n    );\n  }\n\n  /** @internal */\n  _makeTotpVerificationInfo(otp: string): TotpVerificationInfo {\n    return { sessionInfo: this.sessionInfo, verificationCode: otp };\n  }\n\n  /**\n   * Returns a QR code URL as described in\n   * https://github.com/google/google-authenticator/wiki/Key-Uri-Format\n   * This can be displayed to the user as a QR code to be scanned into a TOTP app like Google Authenticator.\n   * If the optional parameters are unspecified, an accountName of <userEmail> and issuer of <firebaseAppName> are used.\n   *\n   * @param accountName the name of the account/app along with a user identifier.\n   * @param issuer issuer of the TOTP (likely the app name).\n   * @returns A QR code URL string.\n   */\n  generateQrCodeUrl(accountName?: string, issuer?: string): string {\n    let useDefaults = false;\n    if (_isEmptyString(accountName) || _isEmptyString(issuer)) {\n      useDefaults = true;\n    }\n    if (useDefaults) {\n      if (_isEmptyString(accountName)) {\n        accountName = this.auth.currentUser?.email || 'unknownuser';\n      }\n      if (_isEmptyString(issuer)) {\n        issuer = this.auth.name;\n      }\n    }\n    return `otpauth://totp/${issuer}:${accountName}?secret=${this.secretKey}&issuer=${issuer}&algorithm=${this.hashingAlgorithm}&digits=${this.codeLength}`;\n  }\n}\n\n/** @internal */\nfunction _isEmptyString(input?: string): boolean {\n  return typeof input === 'undefined' || input?.length === 0;\n}\n", "'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar totp = require('./totp-50d5d5dd.js');\nrequire('@firebase/app');\nrequire('@firebase/util');\nrequire('@firebase/component');\nrequire('@firebase/logger');\n\n\n\nexports.ActionCodeOperation = totp.ActionCodeOperation;\nexports.ActionCodeURL = totp.ActionCodeURL;\nexports.AuthCredential = totp.AuthCredential;\nexports.AuthErrorCodes = totp.AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY;\nexports.EmailAuthCredential = totp.EmailAuthCredential;\nexports.EmailAuthProvider = totp.EmailAuthProvider;\nexports.FacebookAuthProvider = totp.FacebookAuthProvider;\nexports.FactorId = totp.FactorId;\nexports.GithubAuthProvider = totp.GithubAuthProvider;\nexports.GoogleAuthProvider = totp.GoogleAuthProvider;\nexports.OAuthCredential = totp.OAuthCredential;\nexports.OAuthProvider = totp.OAuthProvider;\nexports.OperationType = totp.OperationType;\nexports.PhoneAuthCredential = totp.PhoneAuthCredential;\nexports.PhoneAuthProvider = totp.PhoneAuthProvider;\nexports.PhoneMultiFactorGenerator = totp.PhoneMultiFactorGenerator;\nexports.ProviderId = totp.ProviderId;\nexports.RecaptchaVerifier = totp.RecaptchaVerifier;\nexports.SAMLAuthProvider = totp.SAMLAuthProvider;\nexports.SignInMethod = totp.SignInMethod;\nexports.TotpMultiFactorGenerator = totp.TotpMultiFactorGenerator;\nexports.TotpSecret = totp.TotpSecret;\nexports.TwitterAuthProvider = totp.TwitterAuthProvider;\nexports.applyActionCode = totp.applyActionCode;\nexports.beforeAuthStateChanged = totp.beforeAuthStateChanged;\nexports.browserCookiePersistence = totp.browserCookiePersistence;\nexports.browserLocalPersistence = totp.browserLocalPersistence;\nexports.browserPopupRedirectResolver = totp.browserPopupRedirectResolver;\nexports.browserSessionPersistence = totp.browserSessionPersistence;\nexports.checkActionCode = totp.checkActionCode;\nexports.confirmPasswordReset = totp.confirmPasswordReset;\nexports.connectAuthEmulator = totp.connectAuthEmulator;\nexports.createUserWithEmailAndPassword = totp.createUserWithEmailAndPassword;\nexports.debugErrorMap = totp.debugErrorMap;\nexports.deleteUser = totp.deleteUser;\nexports.fetchSignInMethodsForEmail = totp.fetchSignInMethodsForEmail;\nexports.getAdditionalUserInfo = totp.getAdditionalUserInfo;\nexports.getAuth = totp.getAuth;\nexports.getIdToken = totp.getIdToken;\nexports.getIdTokenResult = totp.getIdTokenResult;\nexports.getMultiFactorResolver = totp.getMultiFactorResolver;\nexports.getRedirectResult = totp.getRedirectResult;\nexports.inMemoryPersistence = totp.inMemoryPersistence;\nexports.indexedDBLocalPersistence = totp.indexedDBLocalPersistence;\nexports.initializeAuth = totp.initializeAuth;\nexports.initializeRecaptchaConfig = totp.initializeRecaptchaConfig;\nexports.isSignInWithEmailLink = totp.isSignInWithEmailLink;\nexports.linkWithCredential = totp.linkWithCredential;\nexports.linkWithPhoneNumber = totp.linkWithPhoneNumber;\nexports.linkWithPopup = totp.linkWithPopup;\nexports.linkWithRedirect = totp.linkWithRedirect;\nexports.multiFactor = totp.multiFactor;\nexports.onAuthStateChanged = totp.onAuthStateChanged;\nexports.onIdTokenChanged = totp.onIdTokenChanged;\nexports.parseActionCodeURL = totp.parseActionCodeURL;\nexports.prodErrorMap = totp.prodErrorMap;\nexports.reauthenticateWithCredential = totp.reauthenticateWithCredential;\nexports.reauthenticateWithPhoneNumber = totp.reauthenticateWithPhoneNumber;\nexports.reauthenticateWithPopup = totp.reauthenticateWithPopup;\nexports.reauthenticateWithRedirect = totp.reauthenticateWithRedirect;\nexports.reload = totp.reload;\nexports.revokeAccessToken = totp.revokeAccessToken;\nexports.sendEmailVerification = totp.sendEmailVerification;\nexports.sendPasswordResetEmail = totp.sendPasswordResetEmail;\nexports.sendSignInLinkToEmail = totp.sendSignInLinkToEmail;\nexports.setPersistence = totp.setPersistence;\nexports.signInAnonymously = totp.signInAnonymously;\nexports.signInWithCredential = totp.signInWithCredential;\nexports.signInWithCustomToken = totp.signInWithCustomToken;\nexports.signInWithEmailAndPassword = totp.signInWithEmailAndPassword;\nexports.signInWithEmailLink = totp.signInWithEmailLink;\nexports.signInWithPhoneNumber = totp.signInWithPhoneNumber;\nexports.signInWithPopup = totp.signInWithPopup;\nexports.signInWithRedirect = totp.signInWithRedirect;\nexports.signOut = totp.signOut;\nexports.unlink = totp.unlink;\nexports.updateCurrentUser = totp.updateCurrentUser;\nexports.updateEmail = totp.updateEmail;\nexports.updatePassword = totp.updatePassword;\nexports.updatePhoneNumber = totp.updatePhoneNumber;\nexports.updateProfile = totp.updateProfile;\nexports.useDeviceLanguage = totp.useDeviceLanguage;\nexports.validatePassword = totp.validatePassword;\nexports.verifyBeforeUpdateEmail = totp.verifyBeforeUpdateEmail;\nexports.verifyPasswordResetCode = totp.verifyPasswordResetCode;\n//# sourceMappingURL=index.js.map\n", "'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar auth = require('@firebase/auth');\n\n\n\nObject.keys(auth).forEach(function (k) {\n\tif (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return auth[k]; }\n\t});\n});\n//# sourceMappingURL=index.cjs.js.map\n", "/**\n * uuu.gl Markdown Uploader Plugin for Obsidian\n *\n * Upload your Obsidian notes to uuu.gl as beautifully rendered Markdown documents\n * with all images and internal links preserved.\n */\n\nimport { Plugin, TFile, Notice } from 'obsidian';\nimport { AuthManager } from './auth-manager';\nimport { UploadModal } from './upload-modal';\nimport { UuuglSettingTab, UuuglPluginSettings, DEFAULT_SETTINGS } from './settings';\nimport FingerprintJS from '@fingerprintjs/fingerprintjs';\n\nexport default class UuuglPlugin extends Plugin {\n  settings: UuuglPluginSettings = DEFAULT_SETTINGS;\n  authManager: AuthManager = new AuthManager();\n  fingerprint: string = '';\n  statusBarItem: HTMLElement | null = null;\n  // Memory-based URL storage (file path -> uuu.gl URL)\n  urlCache: Map<string, string> = new Map();\n\n  async onload() {\n    console.log('\u2705 Loading uuu.gl Markdown Uploader plugin');\n\n    // Load settings\n    await this.loadSettings();\n\n    // Restore URL cache from settings (persistent storage)\n    this.restoreUrlCacheFromSettings();\n\n    // Initialize fingerprint\n    await this.initializeFingerprint();\n\n    // Auto re-authenticate in background (non-blocking for fast startup)\n    this.autoReauthenticate().catch((err) => {\n      console.error('\u274C Background re-authentication failed:', err);\n    });\n\n    // Monitor Firebase auth state changes\n    this.monitorAuthState();\n\n    // Add settings tab\n    this.addSettingTab(new UuuglSettingTab(this.app, this));\n\n    // Initialize URL cache from frontmatter (non-blocking)\n    this.initializeUrlCache().catch((err) => {\n      console.error('\u274C Failed to initialize URL cache:', err);\n    });\n\n    // Add status bar item\n    this.statusBarItem = this.addStatusBarItem();\n    this.statusBarItem.addClass('uuugl-status-bar');\n    // Note: updateStatusBar() is called after cache initialization completes\n\n    // Listen to active file changes\n    this.registerEvent(\n      this.app.workspace.on('active-leaf-change', () => {\n        this.updateStatusBar();\n      })\n    );\n\n    // Listen to file changes (for frontmatter updates)\n    this.registerEvent(\n      this.app.vault.on('modify', (file) => {\n        const activeFile = this.app.workspace.getActiveFile();\n        if (file === activeFile) {\n          this.updateStatusBar();\n        }\n      })\n    );\n\n    // Register obsidian:// URL handler for auth callbacks\n    this.registerObsidianProtocolHandler('uuugl-uploader', (params) => {\n      console.log('\uD83D\uDD17 Received obsidian:// URL:', params);\n\n      // Reconstruct full URI for auth manager\n      const uri = `obsidian://uuugl-uploader${params.action ? '/' + params.action : ''}?${new URLSearchParams(params).toString()}`;\n\n      // Handle auth callback\n      const handled = this.authManager.handleCallback(uri);\n      if (handled) {\n        console.log('\u2705 Auth callback handled successfully');\n      }\n    });\n\n    // Add ribbon icon\n    this.addRibbonIcon('upload-cloud', 'Upload note to uuu.gl', async () => {\n      await this.handleUploadCommand();\n    });\n\n    // Add command: Upload current note\n    this.addCommand({\n      id: 'upload-markdown',\n      name: 'Upload current note to uuu.gl',\n      checkCallback: (checking: boolean) => {\n        const activeFile = this.app.workspace.getActiveFile();\n        if (activeFile) {\n          if (!checking) {\n            this.handleUploadCommand();\n          }\n          return true;\n        }\n        return false;\n      },\n    });\n\n    // Add command: Upload with custom shortcode\n    this.addCommand({\n      id: 'upload-markdown-custom',\n      name: 'Upload current note with custom shortcode',\n      checkCallback: (checking: boolean) => {\n        const activeFile = this.app.workspace.getActiveFile();\n        if (activeFile) {\n          if (!checking) {\n            this.openUploadModal(activeFile);\n          }\n          return true;\n        }\n        return false;\n      },\n    });\n\n    // Add command: Copy uuu.gl link\n    this.addCommand({\n      id: 'copy-uuugl-link',\n      name: 'Copy uuu.gl link',\n      checkCallback: (checking: boolean) => {\n        const activeFile = this.app.workspace.getActiveFile();\n        if (activeFile) {\n          const url = this.getUuuglLinkFromFile(activeFile);\n          if (url) {\n            if (!checking) {\n              navigator.clipboard.writeText(url);\n              new Notice('\uD83D\uDCCE uuu.gl link copied to clipboard!');\n            }\n            return true;\n          }\n        }\n        return false;\n      },\n    });\n\n    console.log('\u2705 uuu.gl plugin loaded successfully');\n  }\n\n  async onunload() {\n    console.log('Unloading uuu.gl plugin');\n  }\n\n  async loadSettings() {\n    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n  }\n\n  async saveSettings() {\n    await this.saveData(this.settings);\n  }\n\n  /**\n   * Restore URL cache from persistent settings storage\n   */\n  private restoreUrlCacheFromSettings() {\n    if (this.settings.urlCache && typeof this.settings.urlCache === 'object') {\n      // Convert settings object to Map\n      for (const [filePath, url] of Object.entries(this.settings.urlCache)) {\n        this.urlCache.set(filePath, url);\n      }\n      console.log(`\u2705 Restored ${this.urlCache.size} URLs from persistent storage`);\n    }\n  }\n\n  /**\n   * Initialize URL cache by scanning all markdown files for uuugl frontmatter\n   * (Legacy support - for frontmatter-based storage)\n   */\n  async initializeUrlCache() {\n    try {\n      console.log('\uD83D\uDD04 Initializing URL cache from frontmatter...');\n      const files = this.app.vault.getMarkdownFiles();\n      let cachedCount = 0;\n\n      for (const file of files) {\n        try {\n          const content = await this.app.vault.read(file);\n\n          // Parse frontmatter\n          const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---/;\n          const match = content.match(frontmatterRegex);\n\n          if (!match) continue;\n\n          const frontmatter = match[1];\n          const lines = frontmatter.split('\\n');\n\n          // Find uuugl field\n          for (const line of lines) {\n            if (line.startsWith('uuugl:')) {\n              const url = line.replace('uuugl:', '').trim();\n              if (url) {\n                this.urlCache.set(file.path, url);\n                cachedCount++;\n                break;\n              }\n            }\n          }\n        } catch (error) {\n          // Skip files that can't be read\n          continue;\n        }\n      }\n\n      console.log(`\u2705 URL cache initialized: ${cachedCount} links found`);\n\n      // Update status bar after cache is ready\n      await this.updateStatusBar();\n    } catch (error) {\n      console.error('\u274C Failed to initialize URL cache:', error);\n    }\n  }\n\n  /**\n   * Initialize device fingerprint for rate limiting\n   */\n  async initializeFingerprint() {\n    if (this.settings.fingerprint) {\n      this.fingerprint = this.settings.fingerprint;\n      console.log('\uD83D\uDD11 Loaded existing fingerprint');\n      return;\n    }\n\n    try {\n      const fp = await FingerprintJS.load();\n      const result = await fp.get();\n      this.fingerprint = result.visitorId;\n      this.settings.fingerprint = this.fingerprint;\n      await this.saveSettings();\n      console.log('\uD83D\uDD11 Fingerprint generated:', this.fingerprint);\n    } catch (error) {\n      console.error('\u274C Failed to generate fingerprint:', error);\n      // Fallback to timestamp-based ID\n      this.fingerprint = `obsidian-${Date.now()}`;\n      this.settings.fingerprint = this.fingerprint;\n      await this.saveSettings();\n    }\n  }\n\n  /**\n   * Auto re-authenticate using saved credentials\n   */\n  async autoReauthenticate() {\n    // If already authenticated, skip\n    if (this.authManager.isAuthenticated()) {\n      console.log('\u2705 Already authenticated');\n      return;\n    }\n\n    // If we have saved email and uid, try to re-authenticate\n    if (this.settings.email && this.settings.uid) {\n      try {\n        console.log('\uD83D\uDD04 Attempting auto re-authentication for:', this.settings.email);\n\n        // Call Firebase Function to generate custom token\n        const { functions } = await import('./firebase-config');\n        const { httpsCallable } = await import('firebase/functions');\n\n        const generateCustomToken = httpsCallable(functions, 'generateCustomToken');\n        const result = await generateCustomToken({ email: this.settings.email });\n        const { customToken } = result.data as any;\n\n        // Sign in with custom token\n        const { auth } = await import('./firebase-config');\n        const { signInWithCustomToken } = await import('firebase/auth');\n\n        await signInWithCustomToken(auth, customToken);\n        console.log('\u2705 Auto re-authentication successful');\n      } catch (error: any) {\n        console.error('\u274C Auto re-authentication failed:', error);\n        // Clear invalid credentials\n        this.settings.email = '';\n        this.settings.uid = '';\n        await this.saveSettings();\n      }\n    }\n  }\n\n  /**\n   * Handle upload command\n   */\n  async handleUploadCommand() {\n    const activeFile = this.app.workspace.getActiveFile();\n\n    if (!activeFile) {\n      new Notice('No active file to upload');\n      return;\n    }\n\n    // Authenticate if needed\n    try {\n      if (!this.authManager.isAuthenticated()) {\n        new Notice('\uD83D\uDD10 Signing in with Google...');\n        const user = await this.authManager.signInWithGoogle();\n\n        // Save email and UID to settings for auto re-authentication\n        if (user.email && user.uid) {\n          this.settings.email = user.email;\n          this.settings.uid = user.uid;\n          await this.saveSettings();\n        }\n\n        new Notice(`\u2705 Welcome, ${user.email || 'User'}!`);\n      }\n\n      // Open upload modal\n      this.openUploadModal(activeFile);\n    } catch (error: any) {\n      console.error('\u274C Authentication failed:', error);\n      new Notice(`\u274C Authentication failed: ${error.message}`);\n    }\n  }\n\n  /**\n   * Monitor Firebase authentication state\n   */\n  private monitorAuthState() {\n    const { auth } = require('./firebase-config');\n    const { onAuthStateChanged } = require('firebase/auth');\n\n    onAuthStateChanged(auth, (user: any) => {\n      if (user) {\n        console.log('\u2705 User authenticated:', user.email);\n\n        // Update email and UID in settings\n        if (user.email && user.uid) {\n          if (this.settings.email !== user.email || this.settings.uid !== user.uid) {\n            this.settings.email = user.email;\n            this.settings.uid = user.uid;\n            this.saveSettings();\n          }\n        }\n      } else {\n        console.log('\u2139\uFE0F No user authenticated');\n      }\n    });\n  }\n\n  /**\n   * Open upload modal\n   */\n  private openUploadModal(file: TFile) {\n    const modal = new UploadModal(\n      this.app,\n      file,\n      this.authManager,\n      this, // Pass plugin instance\n      this.settings.defaultShortCodePrefix\n    );\n    modal.open();\n  }\n\n  /**\n   * Update status bar with current file's uuu.gl link\n   */\n  public async updateStatusBar() {\n    if (!this.statusBarItem) return;\n\n    const activeFile = this.app.workspace.getActiveFile();\n    if (!activeFile) {\n      this.statusBarItem.setText('');\n      return;\n    }\n\n    const url = await this.getUuuglLinkFromFile(activeFile);\n    if (url) {\n      // Extract shortCode from URL for compact display\n      const shortCode = url.replace('https://uuu.gl/', '');\n      this.statusBarItem.setText(`\uD83D\uDD17 ${shortCode}`);\n      this.statusBarItem.setAttribute('title', `Click to copy: ${url}`);\n\n      // Make it clickable to copy URL\n      this.statusBarItem.onclick = () => {\n        navigator.clipboard.writeText(url);\n        new Notice('\uD83D\uDCCE uuu.gl link copied to clipboard!');\n      };\n      this.statusBarItem.style.cursor = 'pointer';\n    } else {\n      this.statusBarItem.setText('');\n      this.statusBarItem.onclick = null;\n      this.statusBarItem.style.cursor = 'default';\n    }\n  }\n\n  /**\n   * Get uuu.gl link from memory cache or file's frontmatter\n   */\n  private async getUuuglLinkFromFile(file: TFile): Promise<string | null> {\n    try {\n      // First check memory cache\n      const cachedUrl = this.urlCache.get(file.path);\n      if (cachedUrl) {\n        return cachedUrl;\n      }\n\n      // Then check frontmatter\n      const content = await this.app.vault.read(file);\n\n      // Parse frontmatter\n      const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---/;\n      const match = content.match(frontmatterRegex);\n\n      if (!match) return null;\n\n      const frontmatter = match[1];\n      const lines = frontmatter.split('\\n');\n\n      // Find uuugl field\n      for (const line of lines) {\n        if (line.startsWith('uuugl:')) {\n          const url = line.replace('uuugl:', '').trim();\n          if (url) {\n            // Cache it for future use\n            this.urlCache.set(file.path, url);\n            return url;\n          }\n        }\n      }\n\n      return null;\n    } catch (error) {\n      console.error('Failed to read uuu.gl link:', error);\n      return null;\n    }\n  }\n\n  /**\n   * Set uuu.gl URL for a file (in memory cache only)\n   */\n  public setUuuglUrl(file: TFile, url: string) {\n    this.urlCache.set(file.path, url);\n  }\n\n  /**\n   * Remove uuu.gl URL from cache\n   */\n  public removeUuuglUrl(file: TFile) {\n    this.urlCache.delete(file.path);\n  }\n\n  /**\n   * Save URL cache to persistent settings storage\n   */\n  public async saveUrlCache() {\n    // Convert Map to plain object\n    const cacheObject: Record<string, string> = {};\n    for (const [filePath, url] of this.urlCache.entries()) {\n      cacheObject[filePath] = url;\n    }\n\n    // Save to settings\n    this.settings.urlCache = cacheObject;\n    await this.saveSettings();\n\n    console.log(`\uD83D\uDCBE Saved ${this.urlCache.size} URLs to persistent storage`);\n  }\n}\n", "/**\n * AuthManager - Mobile Compatible Version\n * Handles Firebase authentication using obsidian:// URL scheme\n * Works on Desktop (Electron), iOS, and Android\n */\n\nimport { auth } from './firebase-config';\nimport { signInWithCustomToken } from 'firebase/auth';\nimport { Notice, Platform } from 'obsidian';\n\nexport interface AuthUser {\n  uid: string;\n  email: string | null;\n  displayName: string | null;\n  photoURL: string | null;\n}\n\nexport class AuthManager {\n  private authCallbacks: Map<string, (token: string) => void> = new Map();\n  private readonly AUTH_URL = 'https://uuu.gl/auth/obsidian';\n\n  /**\n   * Sign in with Google OAuth (cross-platform)\n   * Opens browser for authentication, returns to Obsidian via obsidian:// URL\n   */\n  async signInWithGoogle(): Promise<AuthUser> {\n    return new Promise((resolve, reject) => {\n      // Generate unique callback ID\n      const callbackId = `auth-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;\n\n      console.log('\uD83D\uDD10 Starting cross-platform OAuth flow...');\n\n      // Register callback\n      this.authCallbacks.set(callbackId, async (customToken: string) => {\n        try {\n          console.log('\uD83D\uDD11 Received custom token, authenticating with Firebase...');\n\n          // Sign in with custom token\n          const userCredential = await signInWithCustomToken(auth, customToken);\n          const user = userCredential.user;\n\n          console.log('\u2705 Firebase authentication successful:', user.email);\n\n          const authUser: AuthUser = {\n            uid: user.uid,\n            email: user.email,\n            displayName: user.displayName,\n            photoURL: user.photoURL,\n          };\n\n          // Clean up callback\n          this.authCallbacks.delete(callbackId);\n\n          resolve(authUser);\n        } catch (error: any) {\n          console.error('\u274C Firebase authentication failed:', error);\n          this.authCallbacks.delete(callbackId);\n          reject(error);\n        }\n      });\n\n      // Build auth URL with callback\n      const authUrl = `${this.AUTH_URL}?callbackId=${callbackId}`;\n\n      console.log('\uD83D\uDD17 Opening browser for authentication...');\n      console.log('Platform:', Platform.isDesktopApp ? 'Desktop' : Platform.isMobileApp ? 'Mobile' : 'Unknown');\n\n      // Open browser (cross-platform)\n      this.openExternalBrowser(authUrl);\n\n      // Timeout after 5 minutes\n      setTimeout(() => {\n        if (this.authCallbacks.has(callbackId)) {\n          this.authCallbacks.delete(callbackId);\n          reject(new Error('Authentication timeout'));\n        }\n      }, 5 * 60 * 1000);\n    });\n  }\n\n  /**\n   * Open external browser (cross-platform)\n   */\n  private openExternalBrowser(url: string) {\n    try {\n      if (Platform.isDesktopApp) {\n        // Desktop: Use Electron shell\n        const { shell } = require('electron');\n        shell.openExternal(url);\n        console.log('\uD83D\uDDA5\uFE0F Opened browser via Electron shell');\n      } else {\n        // Mobile: Use Obsidian's built-in method\n        const globalWindow = window as any;\n        if (globalWindow.app && typeof globalWindow.app.openExternal === 'function') {\n          globalWindow.app.openExternal(url);\n          console.log('\uD83D\uDCF1 Opened browser via Obsidian mobile API');\n        } else {\n          // Fallback: Try window.open\n          window.open(url, '_blank');\n          console.log('\uD83C\uDF10 Opened browser via window.open');\n        }\n      }\n    } catch (error: any) {\n      console.error('\u274C Failed to open browser:', error);\n      new Notice('Failed to open browser. Please open this link manually:');\n      new Notice(url);\n    }\n  }\n\n  /**\n   * Handle obsidian:// URL callback\n   * Called by main.ts when URI is opened\n   */\n  handleCallback(uri: string): boolean {\n    try {\n      console.log('\uD83D\uDD17 Handling callback URI:', uri);\n\n      // Parse URI: obsidian://uuugl-uploader/callback?callbackId=xxx&token=yyy\n      const url = new URL(uri);\n\n      // Check if this is our auth callback\n      if (!url.pathname.includes('callback')) {\n        return false;\n      }\n\n      const callbackId = url.searchParams.get('callbackId');\n      const token = url.searchParams.get('token');\n      const error = url.searchParams.get('error');\n\n      if (error) {\n        console.error('\u274C Auth callback error:', error);\n        new Notice(`\u274C Authentication failed: ${error}`);\n\n        // Clear all pending callbacks\n        this.authCallbacks.clear();\n\n        return true;\n      }\n\n      if (!callbackId || !token) {\n        console.error('\u274C Invalid callback URI: missing callbackId or token');\n        return false;\n      }\n\n      // Find and execute callback\n      const callback = this.authCallbacks.get(callbackId);\n      if (callback) {\n        console.log('\u2705 Found callback, executing...');\n        callback(token);\n        return true;\n      } else {\n        console.warn('\u26A0\uFE0F No callback found for callbackId:', callbackId);\n        return false;\n      }\n    } catch (error: any) {\n      console.error('\u274C Failed to handle callback:', error);\n      return false;\n    }\n  }\n\n  /**\n   * Sign out\n   */\n  async signOut(): Promise<void> {\n    await auth.signOut();\n    console.log('\uD83D\uDC4B Signed out');\n  }\n\n  /**\n   * Get current authenticated user\n   */\n  getCurrentUser(): AuthUser | null {\n    const user = auth.currentUser;\n    if (!user) return null;\n\n    return {\n      uid: user.uid,\n      email: user.email,\n      displayName: user.displayName,\n      photoURL: user.photoURL,\n    };\n  }\n\n  /**\n   * Get current authenticated user email\n   */\n  getCurrentUserEmail(): string | null {\n    return auth.currentUser?.email || null;\n  }\n\n  /**\n   * Check if user is authenticated\n   */\n  isAuthenticated(): boolean {\n    return !!auth.currentUser;\n  }\n\n  /**\n   * Get Firebase ID token\n   */\n  async getIdToken(): Promise<string> {\n    const token = await auth.currentUser?.getIdToken();\n    if (!token) {\n      throw new Error('No authentication token available');\n    }\n    return token;\n  }\n}\n", "/**\n * Upload Modal\n * Shows progress and allows user to specify shortcode\n * Detects existing uuu.gl links and offers update/delete options\n */\n\nimport { App, Modal, Notice, TFile } from 'obsidian';\nimport { MarkdownExtractor } from './markdown-extractor';\nimport { ImageUploader } from './image-uploader';\nimport { MemoUploader } from './memo-uploader';\nimport { AuthManager } from './auth-manager';\nimport { httpsCallable } from 'firebase/functions';\nimport { functions } from './firebase-config';\nimport type UuuglPlugin from './main';\n\nexport class UploadModal extends Modal {\n  private file: TFile;\n  private authManager: AuthManager;\n  private defaultPrefix: string;\n  private plugin: UuuglPlugin;\n  private keyword1Input: HTMLInputElement | null = null;\n  private keyword2Input: HTMLInputElement | null = null;\n  private passwordInput: HTMLInputElement | null = null;\n  private urlPreviewEl: HTMLElement | null = null;\n  private progressEl: HTMLElement | null = null;\n  private progressBar: HTMLElement | null = null;\n  private progressText: HTMLElement | null = null;\n  private resultEl: HTMLElement | null = null;\n  private mainContent: HTMLElement | null = null;\n  private existingUrl: string | null = null;\n\n  constructor(\n    app: App,\n    file: TFile,\n    authManager: AuthManager,\n    plugin: UuuglPlugin,\n    defaultPrefix: string = 'obsidian'\n  ) {\n    super(app);\n    this.file = file;\n    this.authManager = authManager;\n    this.plugin = plugin;\n    this.defaultPrefix = defaultPrefix;\n  }\n\n  async onOpen() {\n    const { contentEl } = this;\n    contentEl.addClass('uuugl-upload-modal');\n\n    // Header section\n    const header = contentEl.createDiv({ cls: 'uuugl-modal-header' });\n    header.createEl('h2', { text: 'Upload note to uuu.gl' });\n    header.createEl('p', {\n      text: `File: ${this.file.basename}`,\n      cls: 'uuugl-file-name',\n    });\n\n    // Main content section\n    this.mainContent = contentEl.createDiv({ cls: 'uuugl-modal-content' });\n\n    // Progress container\n    this.progressEl = contentEl.createDiv({ cls: 'uuugl-progress' });\n    this.progressText = this.progressEl.createDiv({ cls: 'uuugl-progress-text' });\n    const progressBarContainer = this.progressEl.createDiv({ cls: 'uuugl-progress-bar-container' });\n    this.progressBar = progressBarContainer.createDiv({ cls: 'uuugl-progress-bar-fill' });\n    this.progressEl.hide();\n\n    // Result container\n    this.resultEl = contentEl.createDiv({ cls: 'uuugl-result' });\n    this.resultEl.hide();\n\n    // Check for existing memo\n    this.existingUrl = await this.checkExistingMemo();\n\n    if (this.existingUrl) {\n      // Show existing memo UI\n      this.renderExistingMemoUI(this.existingUrl);\n    } else {\n      // Show new memo upload UI\n      this.renderNewMemoUI();\n    }\n  }\n\n  onClose() {\n    const { contentEl } = this;\n    contentEl.empty();\n  }\n\n  /**\n   * Check if the file already has a uuu.gl link (memory cache or frontmatter)\n   */\n  private async checkExistingMemo(): Promise<string | null> {\n    try {\n      // First check memory cache\n      const cachedUrl = this.plugin.urlCache.get(this.file.path);\n      if (cachedUrl) {\n        console.log('\u2705 Found URL in memory cache:', cachedUrl);\n        return cachedUrl;\n      }\n\n      // Then check frontmatter\n      const content = await this.app.vault.read(this.file);\n\n      // Parse frontmatter\n      const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---/;\n      const match = content.match(frontmatterRegex);\n\n      if (!match) return null;\n\n      const frontmatter = match[1];\n      const lines = frontmatter.split('\\n');\n\n      // Find uuugl field\n      for (const line of lines) {\n        if (line.startsWith('uuugl:')) {\n          const url = line.replace('uuugl:', '').trim();\n          if (url) {\n            // Cache it for future use\n            this.plugin.setUuuglUrl(this.file, url);\n            console.log('\u2705 Found URL in frontmatter:', url);\n            return url;\n          }\n        }\n      }\n\n      return null;\n    } catch (error) {\n      console.error('Failed to check existing memo:', error);\n      return null;\n    }\n  }\n\n  /**\n   * Render UI for existing memo (Copy/Update/Delete)\n   */\n  private renderExistingMemoUI(url: string) {\n    if (!this.mainContent) return;\n\n    this.mainContent.empty();\n\n    // Extract shortCode from URL\n    const shortCode = url.replace('https://uuu.gl/', '');\n\n    // Info section\n    const infoSection = this.mainContent.createDiv({ cls: 'uuugl-existing-memo-section' });\n\n    const infoTitle = infoSection.createEl('div', {\n      text: '\u2705 This note is already uploaded',\n      cls: 'uuugl-existing-memo-title'\n    });\n\n    const urlDisplay = infoSection.createEl('a', {\n      text: url,\n      href: url,\n      cls: 'uuugl-existing-memo-url'\n    });\n    urlDisplay.setAttribute('target', '_blank');\n\n    const uploadDate = this.mainContent.createDiv({ cls: 'uuugl-existing-memo-date' });\n    uploadDate.setText('\uD83D\uDDD3\uFE0F You can update the memo content or delete it to create a new one');\n\n    // Divider\n    this.mainContent.createDiv({ cls: 'uuugl-section-divider' });\n\n    // Buttons section\n    const buttonsSection = this.mainContent.createDiv({ cls: 'uuugl-existing-memo-buttons' });\n\n    // Copy Link button\n    const copyButton = buttonsSection.createEl('button', {\n      text: '\uD83D\uDCCE Copy Link',\n      cls: 'uuugl-btn uuugl-btn-secondary'\n    });\n    copyButton.addEventListener('click', () => {\n      navigator.clipboard.writeText(url);\n      new Notice('\uD83D\uDCCE Link copied to clipboard!');\n    });\n\n    // Update Memo button\n    const updateButton = buttonsSection.createEl('button', {\n      text: '\uD83D\uDD04 Update Memo',\n      cls: 'uuugl-btn uuugl-btn-primary'\n    });\n    updateButton.addEventListener('click', () => this.handleUpdateMemo(shortCode));\n\n    // Delete Memo button\n    const deleteButton = buttonsSection.createEl('button', {\n      text: '\uD83D\uDDD1\uFE0F Delete Memo',\n      cls: 'uuugl-btn uuugl-btn-danger'\n    });\n    deleteButton.addEventListener('click', () => this.handleDeleteMemo(shortCode));\n  }\n\n  /**\n   * Render UI for new memo upload\n   */\n  private renderNewMemoUI() {\n    if (!this.mainContent) return;\n\n    this.mainContent.empty();\n\n    // ========================================\n    // 1. Password Section (MOVED TO TOP)\n    // ========================================\n    const passwordSection = this.mainContent.createDiv({ cls: 'setting-item uuugl-setting-item' });\n\n    const passwordInfo = passwordSection.createDiv({ cls: 'setting-item-info' });\n    passwordInfo.createDiv({ cls: 'setting-item-name', text: 'Password protection' });\n    passwordInfo.createDiv({ cls: 'setting-item-description', text: 'Optional: Set a password to protect your note' });\n\n    const passwordControl = passwordSection.createDiv({ cls: 'setting-item-control' });\n    this.passwordInput = passwordControl.createEl('input', {\n      type: 'password',\n      placeholder: 'Enter password (optional)',\n      cls: 'uuugl-password-input',\n    });\n\n    // Divider after password\n    const divider1 = this.mainContent.createDiv({ cls: 'uuugl-section-divider' });\n\n    // ========================================\n    // 2. URL Options Section\n    // ========================================\n    const urlOptionsHeader = this.mainContent.createDiv({ cls: 'uuugl-section-header' });\n    urlOptionsHeader.createEl('h3', { text: 'Choose URL type', cls: 'uuugl-section-title' });\n    urlOptionsHeader.createEl('p', {\n      text: 'Create a custom memorable URL or generate a random short code',\n      cls: 'uuugl-section-description'\n    });\n\n    // ========================================\n    // 2.1 Custom URL Option\n    // ========================================\n    const customUrlSection = this.mainContent.createDiv({ cls: 'uuugl-option-section' });\n\n    const customUrlLabel = customUrlSection.createDiv({ cls: 'uuugl-option-label' });\n    customUrlLabel.createEl('span', { text: '\uD83C\uDFAF Custom URL', cls: 'uuugl-option-title' });\n    customUrlLabel.createEl('span', {\n      text: 'keyword1/keyword2',\n      cls: 'uuugl-option-badge'\n    });\n\n    const customUrlDesc = customUrlSection.createDiv({ cls: 'uuugl-option-description' });\n    customUrlDesc.setText('Create a memorable URL with custom keywords');\n\n    // URL input container\n    const urlInputContainer = customUrlSection.createDiv({ cls: 'uuugl-url-input-container' });\n\n    // Prefix\n    urlInputContainer.createEl('span', {\n      text: 'uuu.gl/',\n      cls: 'uuugl-url-prefix'\n    });\n\n    // Keyword 1 input\n    this.keyword1Input = urlInputContainer.createEl('input', {\n      type: 'text',\n      placeholder: 'keyword1',\n      cls: 'uuugl-keyword-input',\n    });\n\n    // Separator\n    urlInputContainer.createEl('span', {\n      text: '/',\n      cls: 'uuugl-url-separator'\n    });\n\n    // Keyword 2 input\n    this.keyword2Input = urlInputContainer.createEl('input', {\n      type: 'text',\n      placeholder: 'keyword2',\n      cls: 'uuugl-keyword-input',\n    });\n\n    // Make custom url button\n    const customUrlButton = customUrlSection.createEl('button', {\n      text: 'Create Custom URL',\n      cls: 'uuugl-btn uuugl-btn-primary',\n    });\n    customUrlButton.addEventListener('click', () => this.handleUpload());\n\n    // \"or\" divider\n    const orDivider = this.mainContent.createDiv({ cls: 'uuugl-divider' });\n    orDivider.createEl('span', { text: 'or' });\n\n    // ========================================\n    // 2.2 Random URL Option\n    // ========================================\n    const randomUrlSection = this.mainContent.createDiv({ cls: 'uuugl-option-section' });\n\n    const randomUrlLabel = randomUrlSection.createDiv({ cls: 'uuugl-option-label' });\n    randomUrlLabel.createEl('span', { text: '\uD83C\uDFB2 Random URL', cls: 'uuugl-option-title' });\n    randomUrlLabel.createEl('span', {\n      text: 'Quick & easy',\n      cls: 'uuugl-option-badge uuugl-option-badge-secondary'\n    });\n\n    const randomUrlDesc = randomUrlSection.createDiv({ cls: 'uuugl-option-description' });\n    randomUrlDesc.setText('Automatically generate a short random code');\n\n    // Random URL button\n    const randomButton = randomUrlSection.createEl('button', {\n      text: 'Generate Random URL',\n      cls: 'uuugl-btn uuugl-btn-secondary',\n    });\n    randomButton.addEventListener('click', async () => {\n      if (this.keyword1Input && this.keyword2Input) {\n        this.keyword1Input.value = this.generateRandomShortCode();\n        this.keyword2Input.value = '';\n        this.updateUrlPreview();\n        await this.handleUpload();\n      }\n    });\n\n    // Set default shortcode\n    const sanitizedName = this.sanitizeShortCode(this.file.basename);\n    if (this.keyword1Input && this.keyword2Input) {\n      this.keyword1Input.value = this.defaultPrefix;\n      this.keyword2Input.value = sanitizedName;\n    }\n\n    // Update preview on input change\n    this.keyword1Input.addEventListener('input', () => this.updateUrlPreview());\n    this.keyword2Input.addEventListener('input', () => this.updateUrlPreview());\n\n    // URL Preview (hidden by default, shown in updateUrlPreview)\n    this.urlPreviewEl = this.contentEl.createDiv({ cls: 'uuugl-url-preview' });\n    this.urlPreviewEl.hide();\n\n    // Focus on keyword1 input\n    if (this.keyword1Input) {\n      this.keyword1Input.focus();\n      this.keyword1Input.select();\n    }\n  }\n\n  /**\n   * Handle memo update\n   */\n  private async handleUpdateMemo(shortCode: string) {\n    try {\n      // Show progress\n      this.progressEl?.show();\n      this.resultEl?.hide();\n      if (this.mainContent) this.mainContent.hide();\n\n      // Step 1: Authenticate (10%)\n      this.updateProgress('\uD83D\uDD10 Authenticating...', 10);\n      if (!this.authManager.isAuthenticated()) {\n        throw new Error('Not authenticated. Please configure your email in settings.');\n      }\n\n      // Step 2: Extract markdown (30%)\n      this.updateProgress('\uD83D\uDCC4 Extracting markdown content...', 30);\n      const extractor = new MarkdownExtractor(this.app, this.app.vault);\n      const extracted = await extractor.extractMarkdown(this.file);\n\n      console.log(`\uD83D\uDCCA Extracted: ${extracted.images.length} images, ${extracted.internalLinks.length} internal links`);\n\n      // Step 3: Get memoId from shortCode using getMemo\n      this.updateProgress('\uD83D\uDD0D Looking up memo...', 50);\n      const memoUploader = new MemoUploader();\n\n      // Get memo to find memoId\n      const getMemoFn = httpsCallable(functions, 'getMemo');\n      const getMemoResult = await getMemoFn({ shortCode });\n      const memoData = getMemoResult.data as any;\n\n      if (!memoData.success || !memoData.memo) {\n        throw new Error('Memo not found. Unable to update.');\n      }\n\n      const memoId = memoData.memo.memoId; // Fix: Use correct field name\n      const currentVersion = memoData.memo.version || 0; // Get current version\n      console.log(`\uD83D\uDCDD Found memo ID: ${memoId}, version: ${currentVersion}`);\n\n      // Step 4: Upload images (70%)\n      let updatedContent = extracted.content;\n      if (extracted.images.length > 0) {\n        this.updateProgress(`\uD83D\uDCE4 Uploading ${extracted.images.length} image(s)...`, 70);\n\n        const imageUploader = new ImageUploader();\n        const uploadedImages = await imageUploader.uploadImages(extracted.images, memoId);\n\n        // Replace image paths in content\n        updatedContent = imageUploader.replaceImagePaths(\n          extracted.content,\n          extracted.images,\n          uploadedImages\n        );\n      }\n\n      // Step 5: Save memo (90%)\n      this.updateProgress('\uD83D\uDCBE Updating memo...', 90);\n      await memoUploader.saveMemo(\n        memoId,\n        shortCode,\n        updatedContent,\n        extracted.images.length > 0 ? [] : [],\n        extracted.internalLinks,\n        currentVersion, // Fix: Pass current version for proper version control\n        null // Password not changeable on update\n      );\n\n      // Complete (100%)\n      this.updateProgress('\u2705 Update complete!', 100);\n\n      // Update URL in memory cache\n      const displayUrl = `https://uuu.gl/${shortCode}`;\n      this.plugin.setUuuglUrl(this.file, displayUrl);\n\n      // Save to persistent storage (IMPORTANT: survives plugin restart)\n      await this.plugin.saveUrlCache();\n\n      // Update status bar\n      // @ts-ignore\n      await this.plugin.updateStatusBar();\n\n      // Show success\n      this.showSuccess(displayUrl, 'Memo updated successfully!');\n\n    } catch (error: any) {\n      console.error('\u274C Update failed:', error);\n      this.showError(error.message || 'Update failed');\n      if (this.mainContent) this.mainContent.show();\n    }\n  }\n\n  /**\n   * Handle memo deletion\n   */\n  private async handleDeleteMemo(shortCode: string) {\n    try {\n      // Confirm deletion\n      const confirmed = confirm(\n        `Are you sure you want to delete this memo?\\n\\n` +\n        `URL: https://uuu.gl/${shortCode}\\n\\n` +\n        `This will remove the memo from uuu.gl and clear the frontmatter. ` +\n        `You can then create a new memo with a different URL.`\n      );\n\n      if (!confirmed) return;\n\n      // Show progress\n      this.progressEl?.show();\n      this.resultEl?.hide();\n      if (this.mainContent) this.mainContent.hide();\n\n      // Step 1: Authenticate\n      this.updateProgress('\uD83D\uDD10 Authenticating...', 20);\n      if (!this.authManager.isAuthenticated()) {\n        throw new Error('Not authenticated. Please configure your email in settings.');\n      }\n\n      // Step 2: Delete memo from server\n      this.updateProgress('\uD83D\uDDD1\uFE0F Deleting memo from server...', 50);\n      const deleteMemoFn = httpsCallable(functions, 'deleteMemo');\n      await deleteMemoFn({ shortCode });\n\n      // Complete\n      this.updateProgress('\u2705 Deletion complete!', 100);\n\n      // Remove URL from memory cache\n      this.plugin.removeUuuglUrl(this.file);\n\n      // Save to persistent storage (IMPORTANT: survives plugin restart)\n      await this.plugin.saveUrlCache();\n\n      // Update status bar to remove the link\n      // @ts-ignore - updateStatusBar is a public method\n      await this.plugin.updateStatusBar();\n\n      // Wait a moment then switch to upload UI\n      setTimeout(() => {\n        this.progressEl?.hide();\n        new Notice('\u2705 Memo deleted successfully! You can now create a new one.');\n        this.existingUrl = null;\n        this.renderNewMemoUI();\n        if (this.mainContent) this.mainContent.show();\n      }, 1000);\n\n    } catch (error: any) {\n      console.error('\u274C Deletion failed:', error);\n      this.showError(error.message || 'Deletion failed');\n      if (this.mainContent) this.mainContent.show();\n    }\n  }\n\n  private updateUrlPreview() {\n    if (!this.urlPreviewEl || !this.keyword1Input) return;\n\n    const keyword1 = this.keyword1Input.value.trim();\n    const keyword2 = this.keyword2Input?.value.trim() || '';\n\n    let previewUrl = 'https://uuu.gl/';\n    if (keyword1 && keyword2) {\n      // Both keywords: uuu.gl/keyword1/keyword2\n      previewUrl += `${keyword1}/${keyword2}`;\n    } else if (keyword1) {\n      // Single keyword (e.g., random): uuu.gl/keyword1\n      previewUrl += keyword1;\n    } else {\n      // No input yet\n      previewUrl += '[enter-keyword]';\n    }\n\n    this.urlPreviewEl.empty();\n    this.urlPreviewEl.createEl('span', {\n      text: `\uD83D\uDCCE Your note will be accessible at: `,\n      cls: 'upload-modal-url-label',\n    });\n    const urlText = this.urlPreviewEl.createEl('span', {\n      text: previewUrl,\n      cls: 'upload-modal-url-text',\n    });\n    urlText.style.fontWeight = 'bold';\n    urlText.style.color = '#5b21b6';\n  }\n\n  private async handleUpload() {\n    if (!this.keyword1Input) return;\n\n    const keyword1 = this.keyword1Input.value.trim();\n    const keyword2 = this.keyword2Input?.value.trim() || '';\n    const password = this.passwordInput?.value.trim() || null;\n\n    // keyword1 is required\n    if (!keyword1) {\n      new Notice('Please enter keyword1');\n      return;\n    }\n\n    // Build shortCode: single code or keyword1/keyword2\n    const shortCode = keyword2 ? `${keyword1}/${keyword2}` : keyword1;\n\n    // Validate keyword1\n    if (!/^[a-zA-Z0-9\uAC00-\uD7A3_-]+$/.test(keyword1)) {\n      new Notice('Keyword1 can only contain letters, numbers, Korean, _, and -');\n      return;\n    }\n\n    // Validate keyword2 if provided\n    if (keyword2 && !/^[a-zA-Z0-9\uAC00-\uD7A3_-]+$/.test(keyword2)) {\n      new Notice('Keyword2 can only contain letters, numbers, Korean, _, and -');\n      return;\n    }\n\n    try {\n      // Show progress\n      this.progressEl?.show();\n      this.resultEl?.hide();\n      if (this.mainContent) this.mainContent.hide();\n\n      // Step 1: Authenticate (10%)\n      this.updateProgress('\uD83D\uDD10 Authenticating...', 10);\n      if (!this.authManager.isAuthenticated()) {\n        throw new Error('Not authenticated. Please configure your email in settings.');\n      }\n\n      // Step 2: Extract markdown (30%)\n      this.updateProgress('\uD83D\uDCC4 Extracting markdown content...', 30);\n      const extractor = new MarkdownExtractor(this.app, this.app.vault);\n      const extracted = await extractor.extractMarkdown(this.file);\n\n      console.log(`\uD83D\uDCCA Extracted: ${extracted.images.length} images, ${extracted.internalLinks.length} internal links`);\n\n      // Log extracted image details\n      if (extracted.images.length > 0) {\n        console.log('\uD83D\uDCF7 Image details:');\n        extracted.images.forEach((img, idx) => {\n          console.log(`  ${idx + 1}. ${img.name} (${(img.size / 1024).toFixed(1)}KB, ${img.mimeType})`);\n          console.log(`     Original path: ${img.originalPath}`);\n        });\n      }\n\n      // Step 3: Create memo (50%)\n      this.updateProgress('\uD83D\uDCDD Creating memo...', 50);\n      const memoUploader = new MemoUploader();\n      const { memoId } = await memoUploader.createMemo(shortCode, password);\n\n      // Step 4: Upload images (70%)\n      let updatedContent = extracted.content;\n      if (extracted.images.length > 0) {\n        this.updateProgress(`\uD83D\uDCE4 Uploading ${extracted.images.length} image(s)...`, 70);\n\n        // Verify authentication before uploading images\n        console.log('\uD83D\uDD11 User authenticated:', this.authManager.isAuthenticated());\n        console.log('\uD83D\uDC64 Current user:', this.authManager.getCurrentUserEmail());\n\n        const imageUploader = new ImageUploader();\n        const uploadedImages = await imageUploader.uploadImages(extracted.images, memoId);\n\n        // Replace image paths in content\n        updatedContent = imageUploader.replaceImagePaths(\n          extracted.content,\n          extracted.images,\n          uploadedImages\n        );\n      }\n\n      // Step 5: Save memo (90%)\n      this.updateProgress('\uD83D\uDCBE Saving memo...', 90);\n      await memoUploader.saveMemo(\n        memoId,\n        shortCode,\n        updatedContent,\n        extracted.images.length > 0 ? [] : [], // Images are already in content as URLs\n        extracted.internalLinks,\n        0,\n        password\n      );\n\n      // Complete (100%)\n      this.updateProgress('\u2705 Upload complete!', 100);\n\n      // Save URL to memory cache\n      const displayUrl = `https://uuu.gl/${shortCode}`;\n      this.plugin.setUuuglUrl(this.file, displayUrl);\n\n      // Save to persistent storage (IMPORTANT: survives plugin restart)\n      await this.plugin.saveUrlCache();\n\n      // Update status bar (DO NOT update frontmatter - user's content must not be modified)\n      // @ts-ignore - updateStatusBar is a public method\n      await this.plugin.updateStatusBar();\n\n      // Show success\n      this.showSuccess(displayUrl, 'Note uploaded successfully!');\n\n    } catch (error: any) {\n      console.error('\u274C Upload failed:', error);\n      this.showError(error.message || 'Upload failed');\n      if (this.mainContent) this.mainContent.show();\n    }\n  }\n\n  private updateProgress(message: string, percentage?: number) {\n    if (this.progressText) {\n      this.progressText.setText(message);\n    }\n    if (this.progressBar && percentage !== undefined) {\n      this.progressBar.style.width = `${percentage}%`;\n    }\n  }\n\n  private showSuccess(url: string, message: string = 'Upload successful!') {\n    if (!this.resultEl) return;\n\n    this.progressEl?.hide();\n    this.resultEl.empty();\n    this.resultEl.show();\n    this.resultEl.addClass('uuugl-success-container');\n\n    // Success icon and message\n    const successHeader = this.resultEl.createDiv({ cls: 'uuugl-success-header' });\n    successHeader.createEl('div', {\n      text: `\u2705 ${message}`,\n      cls: 'uuugl-success-title',\n    });\n\n    // URL display\n    const urlSection = this.resultEl.createDiv({ cls: 'uuugl-success-url-section' });\n    urlSection.createEl('p', {\n      text: 'Your note is now live at:',\n      cls: 'uuugl-success-label'\n    });\n\n    const link = urlSection.createEl('a', {\n      text: url,\n      href: url,\n      cls: 'uuugl-success-url'\n    });\n    link.setAttribute('target', '_blank');\n\n    // Button container\n    const buttonContainer = this.resultEl.createDiv({ cls: 'uuugl-success-buttons' });\n\n    // Copy Link button (primary)\n    const copyButton = buttonContainer.createEl('button', {\n      text: 'Copy Link',\n      cls: 'uuugl-btn uuugl-btn-primary',\n    });\n    copyButton.addEventListener('click', () => {\n      navigator.clipboard.writeText(url);\n      new Notice('Link copied to clipboard!');\n    });\n\n    // Close button (secondary)\n    const closeButton = buttonContainer.createEl('button', {\n      text: 'Close',\n      cls: 'uuugl-btn uuugl-btn-secondary',\n    });\n    closeButton.addEventListener('click', () => this.close());\n\n    new Notice(`\u2705 ${message}`);\n  }\n\n  private showError(message: string) {\n    if (!this.resultEl) return;\n\n    this.progressEl?.hide();\n    if (this.mainContent) this.mainContent.hide(); // Hide main content when showing error\n    this.resultEl.empty();\n    this.resultEl.show();\n\n    this.resultEl.createEl('div', {\n      text: `\u274C Failed: ${message}`,\n      cls: 'upload-modal-error',\n    });\n\n    const closeButton = this.resultEl.createEl('button', {\n      text: 'Close',\n    });\n    closeButton.addEventListener('click', () => this.close());\n\n    new Notice(`\u274C Failed: ${message}`);\n  }\n\n  private sanitizeShortCode(name: string): string {\n    return name\n      .toLowerCase()\n      .replace(/[^a-zA-Z0-9\uAC00-\uD7A3-]/g, '-')\n      .replace(/-+/g, '-')\n      .replace(/^-|-$/g, '');\n  }\n\n  private generateRandomShortCode(): string {\n    // Generate random 8-character alphanumeric code\n    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n    let result = '';\n    for (let i = 0; i < 8; i++) {\n      result += chars.charAt(Math.floor(Math.random() * chars.length));\n    }\n    return result;\n  }\n\n}\n", "/**\n * Markdown Extractor\n * Extracts markdown content, internal links, and images from Obsidian files\n */\n\nimport { TFile, Vault, App } from 'obsidian';\n\nexport interface MarkdownImage {\n  name: string;\n  data: ArrayBuffer;\n  mimeType: string;\n  size: number;\n  altText?: string;\n  originalPath: string;\n}\n\nexport interface ExtractedMarkdown {\n  content: string;\n  images: MarkdownImage[];\n  internalLinks: string[];\n}\n\nexport class MarkdownExtractor {\n  constructor(private app: App, private vault: Vault) {}\n\n  /**\n   * Extract markdown content, images, and internal links from a file\n   */\n  async extractMarkdown(file: TFile): Promise<ExtractedMarkdown> {\n    // 1. Read markdown content\n    const content = await this.vault.read(file);\n\n    // 2. Extract internal links [[link]]\n    const internalLinks = this.extractInternalLinks(content);\n\n    // 3. Extract and read images\n    const images = await this.extractImages(content, file);\n\n    return {\n      content,\n      images,\n      internalLinks,\n    };\n  }\n\n  /**\n   * Extract internal links from markdown content\n   * Matches [[link]] and [[display|link]] patterns\n   */\n  private extractInternalLinks(content: string): string[] {\n    const regex = /\\[\\[([^\\]]+)\\]\\]/g;\n    const links: string[] = [];\n    let match;\n\n    while ((match = regex.exec(content)) !== null) {\n      // Skip image links (![[image]])\n      const startIndex = match.index;\n      if (startIndex > 0 && content[startIndex - 1] === '!') {\n        continue;\n      }\n\n      // Extract link (handle [[display|target]] format)\n      const linkText = match[1];\n      const parts = linkText.split('|');\n      const target = parts.length > 1 ? parts[1].trim() : parts[0].trim();\n\n      links.push(target);\n    }\n\n    // Remove duplicates\n    return [...new Set(links)];\n  }\n\n  /**\n   * Extract and read image files from markdown content\n   */\n  private async extractImages(content: string, sourceFile: TFile): Promise<MarkdownImage[]> {\n    const images: MarkdownImage[] = [];\n\n    // Match both ![](path) and ![[wikilink]] formats\n    const imageRegex = /!\\[([^\\]]*)\\]\\(([^)]+)\\)|!\\[\\[([^\\]]+)\\]\\]/g;\n    let match;\n\n    while ((match = imageRegex.exec(content)) !== null) {\n      let altText: string | undefined;\n      let imagePath: string;\n\n      if (match[2]) {\n        // Standard markdown: ![alt](path)\n        altText = match[1] || undefined;\n        imagePath = match[2];\n      } else {\n        // Wiki-style: ![[image]]\n        imagePath = match[3];\n        altText = undefined;\n      }\n\n      try {\n        // Resolve image path relative to source file\n        const imageFile = this.app.metadataCache.getFirstLinkpathDest(\n          imagePath,\n          sourceFile.path\n        );\n\n        if (!imageFile) {\n          console.warn(`\u26A0\uFE0F Image not found in vault: ${imagePath}`);\n          console.warn(`Source file path: ${sourceFile.path}`);\n          console.warn(`Looking for: ${imagePath}`);\n          // Skip this image but continue with others\n          continue;\n        }\n\n        // Read image data\n        const data = await this.vault.readBinary(imageFile);\n        const mimeType = this.getMimeType(imageFile.extension);\n\n        images.push({\n          name: imageFile.name,\n          data,\n          mimeType,\n          size: data.byteLength,\n          altText,\n          originalPath: imagePath,\n        });\n\n        console.log(`\uD83D\uDCF7 Extracted image: ${imageFile.name} (${(data.byteLength / 1024).toFixed(1)}KB)`);\n      } catch (error) {\n        console.error(`\u274C Failed to read image: ${imagePath}`, error);\n      }\n    }\n\n    return images;\n  }\n\n  /**\n   * Get MIME type from file extension\n   */\n  private getMimeType(extension: string): string {\n    const mimeTypes: { [key: string]: string } = {\n      'png': 'image/png',\n      'jpg': 'image/jpeg',\n      'jpeg': 'image/jpeg',\n      'gif': 'image/gif',\n      'svg': 'image/svg+xml',\n      'webp': 'image/webp',\n      'bmp': 'image/bmp',\n    };\n\n    return mimeTypes[extension.toLowerCase()] || 'application/octet-stream';\n  }\n}\n", "/**\n * Image Uploader\n * Uploads images to Firebase Storage\n */\n\nimport { storage } from './firebase-config';\nimport { ref, uploadBytes, getDownloadURL } from 'firebase/storage';\nimport { MarkdownImage } from './markdown-extractor';\n\nexport interface UploadedImage {\n  originalName: string;\n  storagePath: string;\n  downloadUrl: string;\n  mimeType: string;\n  size: number;\n  altText?: string;\n}\n\nexport class ImageUploader {\n  /**\n   * Upload images to Firebase Storage\n   * @param images Array of images to upload\n   * @param memoId Memo ID for storage path\n   * @returns Array of uploaded image metadata\n   */\n  async uploadImages(images: MarkdownImage[], memoId: string): Promise<UploadedImage[]> {\n    const uploadedImages: UploadedImage[] = [];\n\n    for (let i = 0; i < images.length; i++) {\n      const image = images[i];\n      try {\n        console.log(`\uD83D\uDCE4 Uploading image ${i + 1}/${images.length}: ${image.name}...`);\n        console.log(`   Size: ${(image.size / 1024).toFixed(1)}KB`);\n        console.log(`   Type: ${image.mimeType}`);\n\n        // Create storage path: memos/{memoId}/images/{imageName}\n        const timestamp = Date.now();\n        const sanitizedName = this.sanitizeFileName(image.name);\n        const storagePath = `memos/${memoId}/images/${timestamp}_${sanitizedName}`;\n\n        console.log(`   Storage path: ${storagePath}`);\n\n        // Create storage reference\n        const storageRef = ref(storage, storagePath);\n\n        // Convert ArrayBuffer to Blob\n        const blob = new Blob([image.data], { type: image.mimeType });\n        console.log(`   Blob created: ${blob.size} bytes`);\n\n        // Upload to Firebase Storage\n        console.log(`   Starting upload...`);\n        const snapshot = await uploadBytes(storageRef, blob, {\n          contentType: image.mimeType,\n        });\n\n        // Get download URL\n        const downloadUrl = await getDownloadURL(snapshot.ref);\n        console.log(`   Download URL: ${downloadUrl}`);\n\n        uploadedImages.push({\n          originalName: image.name,\n          storagePath: snapshot.ref.fullPath,\n          downloadUrl,\n          mimeType: image.mimeType,\n          size: image.size,\n          altText: image.altText,\n        });\n\n        console.log(`\u2705 Image uploaded successfully: ${image.name}`);\n      } catch (error: any) {\n        console.error(`\u274C Failed to upload image: ${image.name}`, error);\n        console.error('Error code:', error.code);\n        console.error('Error message:', error.message);\n        console.error('Full error:', JSON.stringify(error, null, 2));\n\n        // Re-throw the error with more details\n        const errorMsg = error.code === 'storage/unauthorized'\n          ? 'Storage permission denied. Please check Firebase Storage rules.'\n          : error.message || error.code || 'Unknown error';\n\n        throw new Error(`Failed to upload image: ${image.name}\\n${errorMsg}`);\n      }\n    }\n\n    return uploadedImages;\n  }\n\n  /**\n   * Sanitize file name for storage\n   */\n  private sanitizeFileName(fileName: string): string {\n    // Remove special characters and spaces\n    return fileName\n      .replace(/[^a-zA-Z0-9._-]/g, '_')\n      .replace(/_{2,}/g, '_')\n      .toLowerCase();\n  }\n\n  /**\n   * Replace image paths in markdown content with uploaded URLs\n   */\n  replaceImagePaths(\n    content: string,\n    originalImages: MarkdownImage[],\n    uploadedImages: UploadedImage[]\n  ): string {\n    let updatedContent = content;\n\n    for (let i = 0; i < originalImages.length; i++) {\n      const original = originalImages[i];\n      const uploaded = uploadedImages[i];\n\n      if (!uploaded) continue;\n\n      // Replace ![[wikilink]] format\n      const wikiRegex = new RegExp(`!\\\\[\\\\[${this.escapeRegex(original.originalPath)}\\\\]\\\\]`, 'g');\n      updatedContent = updatedContent.replace(\n        wikiRegex,\n        `![${uploaded.altText || uploaded.originalName}](${uploaded.downloadUrl})`\n      );\n\n      // Replace ![](path) format\n      const mdRegex = new RegExp(`!\\\\[([^\\\\]]*)\\\\]\\\\(${this.escapeRegex(original.originalPath)}\\\\)`, 'g');\n      updatedContent = updatedContent.replace(\n        mdRegex,\n        `![$1](${uploaded.downloadUrl})`\n      );\n    }\n\n    return updatedContent;\n  }\n\n  /**\n   * Escape special regex characters\n   */\n  private escapeRegex(str: string): string {\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  }\n}\n", "/**\n * Memo Uploader\n * Handles creating and saving memos via Firebase Functions\n */\n\nimport { functions } from './firebase-config';\nimport { httpsCallable } from 'firebase/functions';\n\nexport interface CreateMemoRequest {\n  shortCode?: string;\n  isPublic?: boolean;\n  password?: string;\n  contentType: 'markdown';\n}\n\nexport interface SaveMemoRequest {\n  shortCode?: string;\n  memoId: string;\n  markdownData: {\n    content: string;\n    images: Array<{\n      id: string;\n      storagePath: string;\n      originalName: string;\n      mimeType: string;\n      size: number;\n      altText?: string;\n    }>;\n    internalLinks: string[];\n  };\n  version?: number;\n}\n\nexport interface MemoUploadResult {\n  success: boolean;\n  memoId: string;\n  shortCode: string;\n  url: string;\n  version: number;\n}\n\nexport class MemoUploader {\n  /**\n   * Create a new Markdown memo\n   */\n  async createMemo(shortCode: string, password?: string | null): Promise<{ memoId: string; shortCode: string }> {\n    console.log(`\uD83D\uDCDD Creating memo with shortCode: ${shortCode}`);\n    if (password) {\n      console.log(`\uD83D\uDD12 Password protection enabled`);\n    }\n\n    const createMemoFunction = httpsCallable(functions, 'createMemo');\n\n    const request: CreateMemoRequest = {\n      shortCode,\n      isPublic: true,\n      contentType: 'markdown',\n    };\n\n    // Add password if provided\n    if (password) {\n      request.password = password;\n    }\n\n    const result = await createMemoFunction(request);\n    const data = result.data as any;\n\n    if (!data.success) {\n      throw new Error(data.error || 'Failed to create memo');\n    }\n\n    console.log(`\u2705 Memo created: ${data.memoId}`);\n\n    return {\n      memoId: data.memoId,\n      shortCode: data.shortCode,\n    };\n  }\n\n  /**\n   * Save markdown content to memo\n   */\n  async saveMemo(\n    memoId: string,\n    shortCode: string,\n    content: string,\n    images: Array<any>,\n    internalLinks: string[],\n    version?: number,\n    password?: string | null\n  ): Promise<MemoUploadResult> {\n    console.log(`\uD83D\uDCBE Saving memo: ${shortCode}`);\n\n    const saveMemoFunction = httpsCallable(functions, 'saveMemo');\n\n    const request: any = {\n      shortCode,\n      memoId,\n      markdownData: {\n        content,\n        images: images.map((img, index) => ({\n          id: `img_${index}`,\n          storagePath: img.storagePath,\n          originalName: img.originalName,\n          mimeType: img.mimeType,\n          size: img.size,\n          altText: img.altText,\n        })),\n        internalLinks,\n      },\n      version,\n    };\n\n    // Add password if provided\n    if (password) {\n      request.password = password;\n    }\n\n    const result = await saveMemoFunction(request);\n    const data = result.data as any;\n\n    if (!data.success) {\n      throw new Error(data.error || 'Failed to save memo');\n    }\n\n    console.log(`\u2705 Memo saved successfully. Version: ${data.version}`);\n\n    return {\n      success: true,\n      memoId,\n      shortCode,\n      url: `https://uuu.gl/md/${shortCode}`,\n      version: data.version || 0,\n    };\n  }\n\n  /**\n   * Complete upload workflow: create + save\n   */\n  async uploadMarkdown(\n    shortCode: string,\n    content: string,\n    images: Array<any>,\n    internalLinks: string[]\n  ): Promise<MemoUploadResult> {\n    // 1. Create memo\n    const { memoId, shortCode: finalShortCode } = await this.createMemo(shortCode);\n\n    // 2. Save content\n    const result = await this.saveMemo(\n      memoId,\n      finalShortCode,\n      content,\n      images,\n      internalLinks,\n      0 // Initial version\n    );\n\n    return result;\n  }\n}\n", "/**\n * Plugin Settings UI\n */\n\nimport { App, PluginSettingTab, Setting, Notice } from 'obsidian';\nimport UuuglPlugin from './main';\n\nexport interface UuuglPluginSettings {\n  email: string;\n  uid: string;\n  fingerprint: string;\n  lastSyncedAt: string;\n  defaultShortCodePrefix: string;\n  urlCache: Record<string, string>; // file path -> uuu.gl URL mapping\n}\n\nexport const DEFAULT_SETTINGS: UuuglPluginSettings = {\n  email: '',\n  uid: '',\n  fingerprint: '',\n  lastSyncedAt: '',\n  defaultShortCodePrefix: 'obsidian',\n  urlCache: {}, // Persistent URL cache\n};\n\nexport class UuuglSettingTab extends PluginSettingTab {\n  plugin: UuuglPlugin;\n\n  constructor(app: App, plugin: UuuglPlugin) {\n    super(app, plugin);\n    this.plugin = plugin;\n  }\n\n  display(): void {\n    const { containerEl } = this;\n\n    containerEl.empty();\n\n    // Header\n    containerEl.createEl('h2', { text: 'uuu.gl Markdown Uploader Settings' });\n\n    // Description\n    containerEl.createEl('p', {\n      text: 'Upload your Obsidian notes to uuu.gl as beautifully rendered Markdown documents.',\n      cls: 'setting-item-description',\n    });\n\n    // Authentication Section\n    containerEl.createEl('h3', { text: 'Authentication' });\n\n    // Current user status\n    const currentUser = this.plugin.authManager.getCurrentUser();\n    if (currentUser) {\n      new Setting(containerEl)\n        .setName('Logged in as')\n        .setDesc(currentUser.email || 'No email')\n        .addButton((button) =>\n          button\n            .setButtonText('Sign Out')\n            .onClick(async () => {\n              await this.plugin.authManager.signOut();\n              this.plugin.settings.email = '';\n              this.plugin.settings.uid = '';\n              await this.plugin.saveSettings();\n              this.display(); // Refresh settings UI\n            })\n        );\n    } else {\n      new Setting(containerEl)\n        .setName('Google Sign In')\n        .setDesc('Sign in with your Google account to upload notes')\n        .addButton((button) =>\n          button\n            .setButtonText('Sign In with Google')\n            .setCta()\n            .onClick(async () => {\n              try {\n                button.setDisabled(true);\n                button.setButtonText('Signing in...');\n\n                const user = await this.plugin.authManager.signInWithGoogle();\n                if (user.email && user.uid) {\n                  this.plugin.settings.email = user.email;\n                  this.plugin.settings.uid = user.uid;\n                  await this.plugin.saveSettings();\n                }\n                this.display(); // Refresh settings UI\n              } catch (error: any) {\n                console.error('Sign in failed:', error);\n                new Notice(`\u274C Sign in failed: ${error.message}`);\n                button.setDisabled(false);\n                button.setButtonText('Sign In with Google');\n              }\n            })\n        );\n    }\n\n    // Storage Usage Section\n    if (currentUser) {\n      containerEl.createEl('h3', { text: 'Storage Usage' });\n\n      const storageContainer = containerEl.createDiv({ cls: 'storage-usage-container' });\n      storageContainer.createEl('p', { text: 'Loading storage information...' });\n\n      // Fetch storage stats\n      this.fetchStorageStats(storageContainer);\n    }\n\n    // Default ShortCode Prefix\n    new Setting(containerEl)\n      .setName('Default ShortCode Prefix')\n      .setDesc('Prefix for auto-generated shortcodes (e.g., \"obsidian/my-note\")')\n      .addText((text) =>\n        text\n          .setPlaceholder('obsidian')\n          .setValue(this.plugin.settings.defaultShortCodePrefix)\n          .onChange(async (value) => {\n            this.plugin.settings.defaultShortCodePrefix = value;\n            await this.plugin.saveSettings();\n          })\n      );\n\n    // Fingerprint (Read-only)\n    new Setting(containerEl)\n      .setName('Device Fingerprint')\n      .setDesc('Unique identifier for this device (auto-generated)')\n      .addText((text) =>\n        text\n          .setValue(this.plugin.settings.fingerprint || 'Not generated yet')\n          .setDisabled(true)\n      );\n\n    // Last Synced\n    if (this.plugin.settings.lastSyncedAt) {\n      new Setting(containerEl)\n        .setName('Last Upload')\n        .setDesc('When you last uploaded a note')\n        .addText((text) =>\n          text\n            .setValue(new Date(this.plugin.settings.lastSyncedAt).toLocaleString())\n            .setDisabled(true)\n        );\n    }\n\n    // Divider\n    containerEl.createEl('hr');\n\n    // How to Use\n    containerEl.createEl('h3', { text: 'How to Use' });\n\n    const instructionsList = containerEl.createEl('ol');\n    instructionsList.createEl('li', { text: 'Enter your email address above' });\n    instructionsList.createEl('li', { text: 'Open any note in Obsidian' });\n    instructionsList.createEl('li', { text: 'Click the upload icon in the ribbon or use the command palette' });\n    instructionsList.createEl('li', { text: 'Choose a shortcode (URL path) for your note' });\n    instructionsList.createEl('li', { text: 'Your note will be uploaded with all images and internal links preserved!' });\n\n    // Support Link\n    containerEl.createEl('p', {\n      text: 'Need help? Visit ',\n    }).createEl('a', {\n      text: 'uuu.gl',\n      href: 'https://uuu.gl',\n    });\n  }\n\n  /**\n   * Fetch and display storage statistics\n   */\n  async fetchStorageStats(container: HTMLElement) {\n    try {\n      const token = await this.plugin.authManager.getIdToken();\n\n      // Call getUserStats Cloud Function using Firebase Functions SDK\n      const { functions } = await import('./firebase-config');\n      const { httpsCallable } = await import('firebase/functions');\n\n      const getUserStats = httpsCallable(functions, 'getUserStats');\n      const result = await getUserStats({});\n      const stats = result.data as any;\n\n      // Clear loading message\n      container.empty();\n\n      // Format bytes to human-readable\n      const formatBytes = (bytes: number) => {\n        if (bytes === 0) return '0 B';\n        const k = 1024;\n        const sizes = ['B', 'KB', 'MB', 'GB'];\n        const i = Math.floor(Math.log(bytes) / Math.log(k));\n        return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];\n      };\n\n      // Storage usage bar\n      const usedBytes = stats.storageUsed || 0;\n      const limitBytes = stats.storageLimit || 0;\n      const usedFormatted = formatBytes(usedBytes);\n      const limitFormatted = limitBytes === -1 ? 'Unlimited' : formatBytes(limitBytes);\n      const percentage = limitBytes === -1 ? 0 : Math.min(100, (usedBytes / limitBytes) * 100);\n\n      // Create storage display\n      new Setting(container)\n        .setName('Storage Used')\n        .setDesc(`${usedFormatted} / ${limitFormatted}`)\n        .setClass('storage-stat');\n\n      // Progress bar\n      const progressContainer = container.createDiv({ cls: 'storage-progress' });\n      progressContainer.createEl('div', {\n        cls: 'storage-progress-bar',\n        attr: {\n          style: `width: ${percentage}%; background-color: ${\n            percentage > 90 ? '#ef4444' : percentage > 70 ? '#f59e0b' : '#22c55e'\n          }`,\n        },\n      });\n\n      // Additional stats\n      new Setting(container)\n        .setName('Total URLs')\n        .setDesc(`${stats.urlCount || 0} URLs created`);\n\n      new Setting(container)\n        .setName('Total Files')\n        .setDesc(`${stats.fileCount || 0} files uploaded`);\n\n      new Setting(container)\n        .setName('Total Clicks')\n        .setDesc(`${stats.totalClicks || 0} clicks on your URLs`);\n\n      // Add CSS for progress bar\n      if (!document.getElementById('uuugl-storage-styles')) {\n        const style = document.createElement('style');\n        style.id = 'uuugl-storage-styles';\n        style.textContent = `\n          .storage-progress {\n            width: 100%;\n            height: 8px;\n            background-color: var(--background-modifier-border);\n            border-radius: 4px;\n            overflow: hidden;\n            margin: 10px 0;\n          }\n          .storage-progress-bar {\n            height: 100%;\n            transition: width 0.3s ease;\n            border-radius: 4px;\n          }\n          .storage-usage-container {\n            padding: 10px 0;\n          }\n        `;\n        document.head.appendChild(style);\n      }\n    } catch (error: any) {\n      console.error('Failed to fetch storage stats:', error);\n      container.empty();\n      container.createEl('p', {\n        text: 'Failed to load storage information',\n        cls: 'mod-warning',\n      });\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": ["name", "querystring", "stringToByteArray", "name", "init_index_esm", "LogLevel", "name", "name", "version", "target", "app", "name", "DEFAULT_ENTRY_NAME", "version", "appName", "appCompatName", "analyticsName", "analyticsCompatName", "appCheckName", "appCheckCompatName", "authName", "authCompatName", "databaseName", "dataconnectName", "databaseCompatName", "functionsName", "functionsCompatName", "installationsName", "installationsCompatName", "messagingName", "messagingCompatName", "performanceName", "performanceCompatName", "remoteConfigName", "remoteConfigCompatName", "storageName", "storageCompatName", "firestoreName", "firestoreCompatName", "aiName", "packageName", "name", "version", "auth", "factory", "app", "applyActionCode", "sendEmailVerification", "sendPasswordResetEmail", "sendSignInLinkToEmail", "signInWithEmailLink", "signInWithPhoneNumber", "linkWithPhoneNumber", "signInWithCustomToken", "getIdTokenResponse", "authentication.sendPasswordResetEmail", "account\n        .resetPassword", "account.applyActionCode", "account.resetPassword", "request", "actionCodeSettings", "api.sendSignInLinkToEmail", "api.sendEmailVerification", "api.verifyAndChangeEmail", "updateProfile", "apiUpdateProfile", "apiUpdateEmailPassword", "name", "version", "IDP_REQUEST_URI", "reload", "jsHelpers._recaptchaEnterpriseScriptUrl", "jsHelpers\n                        ._loadJS", "init_index_esm", "init_dist", "status", "connectFunctionsEmulator", "httpsCallable", "name", "options", "httpsCallableFromURL", "error", "factory", "app", "version", "_connectFunctionsEmulator", "_httpsCallable", "_httpsCallableFromURL", "auth", "dist_exports", "init_dist", "init_index_esm", "name", "canceled", "stop", "encode", "getBlob", "BlobBuilder", "start", "uploadBytes", "ref", "getDownloadURL", "requestsGetDownloadUrl", "_getChild", "connectStorageEmulator", "storage", "uploadBytesInternal", "getDownloadURLInternal", "refInternal", "app", "connectEmulatorInternal", "version", "StorageErrorCode", "ErrorCode", "auth", "init_dist", "init_index_node_esm", "init_dist", "exports", "version", "name", "sources", "index", "AudioContext", "_a", "_b", "document", "exports", "CONSTANTS", "stringToByteArray", "byteArrayToString", "base64", "DecodeBase64StringError", "base64Encode", "base64urlEncodeWithoutPadding", "base64Decode", "getGlobal", "getDefaultsFromGlobal", "getDefaultsFromEnvVariable", "getDefaultsFromCookie", "getDefaults", "getDefaultsFromPostinstall", "getDefaultEmulatorHost", "getDefaultEmulatorHostnameAndPort", "getDefaultAppConfig", "name", "Deferred", "isCloudWorkstation", "pingServer", "createMockUserToken", "emulatorStatus", "getEmulatorSummary", "getOrCreateEl", "previouslyDismissed", "updateEmulatorBanner", "getUA", "isMobileCordova", "isBrowser", "isWebWorker", "isCloudflareWorker", "isBrowserExtension", "isReactNative", "isIE", "isIndexedDBAvailable", "validateIndexedDBOpenable", "ERROR_NAME", "FirebaseError", "ErrorFactory", "replaceTemplate", "PATTERN", "decode", "deepEqual", "isObject", "querystring", "querystringDecode", "extractQuerystring", "createSubscribe", "ObserverProxy", "implementsAnyMethods", "noop", "MAX_VALUE_MILLIS", "getModularInstance", "Component", "name", "DEFAULT_ENTRY_NAME", "Provider", "Deferred", "isComponentEager", "normalizeIdentifierForFactory", "ComponentContainer", "instances", "LogLevel", "levelStringToEnum", "defaultLogLevel", "ConsoleMethod", "defaultLogHandler", "Logger", "name", "setLogLevel", "setUserLogHandler", "instance", "PlatformLoggerServiceImpl", "isVersionServiceProvider", "component", "logger", "Logger", "DEFAULT_ENTRY_NAME", "PLATFORM_LOG_STRING", "appName", "appCompatName", "analyticsName", "analyticsCompatName", "appCheckName", "appCheckCompatName", "authName", "authCompatName", "databaseName", "dataconnectName", "databaseCompatName", "functionsName", "functionsCompatName", "installationsName", "installationsCompatName", "messagingName", "messagingCompatName", "performanceName", "performanceCompatName", "remoteConfigName", "remoteConfigCompatName", "storageName", "storageCompatName", "firestoreName", "firestoreCompatName", "aiName", "packageName", "_apps", "_serverApps", "_components", "_addComponent", "app", "_registerComponent", "_getProvider", "name", "_isFirebaseServerApp", "ERRORS", "ERROR_FACTORY", "ErrorFactory", "FirebaseAppImpl", "Component", "base64Decode", "registerVersion", "version", "SDK_VERSION", "initializeApp", "getDefaultAppConfig", "deepEqual", "ComponentContainer", "isBrowser", "isWebWorker", "getApp", "setUserLogHandler", "setLogLevel", "setLogLevelImpl", "DB_NAME", "DB_VERSION", "STORE_NAME", "dbPromise", "getDbPromise", "openDB", "readHeartbeatsFromIndexedDB", "computeKey", "FirebaseError", "writeHeartbeatsToIndexedDB", "MAX_HEADER_BYTES", "MAX_NUM_STORED_HEARTBEATS", "HeartbeatServiceImpl", "HeartbeatStorageImpl", "getUTCDateString", "getEarliestHeartbeatIdx", "extractHeartbeatsForHeader", "base64urlEncodeWithoutPadding", "countBytes", "isIndexedDBAvailable", "validateIndexedDBOpenable", "registerCoreComponents", "FactorId", "ProviderId", "SignInMethod", "OperationType", "ActionCodeOperation", "_debugErrorMap", "_prodErrorMap", "debugErrorMap", "prodErrorMap", "_DEFAULT_AUTH_ERROR_FACTORY", "ErrorFactory", "AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY", "logClient", "Logger", "_logWarn", "LogLevel", "SDK_VERSION", "_logError", "_fail", "createErrorInternal", "_createError", "_errorWithCustomMessage", "auth", "factory", "_serverAppCurrentUserOperationNotSupportedError", "_assert", "debugFail", "debugAssert", "_getCurrentUrl", "_isHttpOrHttps", "_getCurrentScheme", "_isOnline", "isBrowserExtension", "_getUserLanguage", "Delay", "isMobileCordova", "isReactNative", "_emulatorUrl", "FetchProvider", "SERVER_ERROR_MAP", "CookieAuthProxiedEndpoints", "DEFAULT_API_TIMEOUT_MS", "_addTidIfNecessary", "_performApiRequest", "_performFetchWithErrorHandling", "querystring", "isCloudflareWorker", "isCloudWorkstation", "_getFinalTarget", "NetworkTimeout", "_makeTaggedError", "FirebaseError", "_performSignInRequest", "_parseEnforcementState", "isEnterprise", "RecaptchaConfig", "getRecaptchaConfig", "deleteAccount", "deleteLinkedAccounts", "getAccountInfo", "utcTimestampToDateString", "getIdToken", "getModularInstance", "getIdTokenResult", "_parseToken", "secondsStringToMilliseconds", "base64Decode", "_tokenExpiresIn", "_logoutIfInvalidated", "isUserInvalidated", "ProactiveRefresh", "UserMetadata", "_reloadWithoutSaving", "extractProviderData", "mergeProviderData", "reload", "requestStsToken", "revokeToken", "StsTokenManager", "assertStringOrUndefined", "UserImpl", "_isFirebaseServerApp", "instanceCache", "_getInstance", "InMemoryPersistence", "inMemoryPersistence", "_persistenceKeyName", "PersistenceUserManager", "name", "_getBrowserName", "_isIEMobile", "_isFirefox", "_isBlackBerry", "_isWebOS", "_isSafari", "_isChromeIOS", "_isAndroid", "getUA", "isIE", "_getClientVersion", "AuthMiddlewareQueue", "_getPasswordPolicy", "MINIMUM_MIN_PASSWORD_LENGTH", "PasswordPolicyImpl", "AuthImpl", "app", "Subscription", "_castAuth", "createSubscribe", "externalJSProvider", "_loadJS", "_recaptchaEnterpriseScriptUrl", "MockGreCAPTCHATopLevel", "MockGreCAPTCHA", "RECAPTCHA_ENTERPRISE_VERIFIER_TYPE", "FAKE_TOKEN", "RecaptchaEnterpriseVerifier", "jsHelpers._recaptchaEnterpriseScriptUrl", "jsHelpers\n                        ._loadJS", "injectRecaptchaFields", "handleRecaptchaFlow", "_initializeRecaptchaConfig", "initializeAuth", "_getProvider", "deepEqual", "_initializeAuthInstance", "connectAuthEmulator", "extractProtocol", "extractHostAndPort", "pingServer", "updateEmulatorBanner", "emitEmulatorWarning", "parsePort", "AuthCredential", "resetPassword", "updateEmailPassword", "linkEmailPassword", "applyActionCode", "signInWithPassword", "sendOobCode", "sendEmailVerification", "sendPasswordResetEmail", "sendSignInLinkToEmail", "verifyAndChangeEmail", "signInWithEmailLink", "signInWithEmailLinkForLinking", "EmailAuthCredential", "signInWithIdp", "IDP_REQUEST_URI", "OAuthCredential", "signInWithPhoneNumber", "linkWithPhoneNumber", "VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_", "verifyPhoneNumberForExisting", "PhoneAuthCredential", "parseMode", "parseDeepLink", "querystringDecode", "extractQuerystring", "ActionCodeURL", "parseActionCodeURL", "EmailAuthProvider", "FederatedAuthProvider", "BaseOAuthProvider", "OAuthProvider", "FacebookAuthProvider", "GoogleAuthProvider", "GithubAuthProvider", "SAMLAuthCredential", "SAML_PROVIDER_PREFIX", "SAMLAuthProvider", "TwitterAuthProvider", "signUp", "UserCredentialImpl", "providerIdForResponse", "signInAnonymously", "MultiFactorError", "_processCredentialSavingMfaContextIfNecessary", "providerDataAsNames", "unlink", "_assertLinkedStatus", "_link", "_reauthenticate", "_signInWithCredential", "signInWithCredential", "linkWithCredential", "reauthenticateWithCredential", "signInWithCustomToken", "getIdTokenResponse", "MultiFactorInfoImpl", "PhoneMultiFactorInfoImpl", "TotpMultiFactorInfoImpl", "_setActionCodeSettingsOnRequest", "recachePasswordPolicy", "authentication.sendPasswordResetEmail", "confirmPasswordReset", "account\n        .resetPassword", "account.applyActionCode", "checkActionCode", "account.resetPassword", "verifyPasswordResetCode", "createUserWithEmailAndPassword", "signInWithEmailAndPassword", "request", "actionCodeSettings", "api.sendSignInLinkToEmail", "isSignInWithEmailLink", "createAuthUri", "fetchSignInMethodsForEmail", "api.sendEmailVerification", "verifyBeforeUpdateEmail", "api.verifyAndChangeEmail", "updateProfile", "apiUpdateProfile", "updateEmail", "updateEmailOrPassword", "updatePassword", "apiUpdateEmailPassword", "_fromIdTokenResponse", "GenericAdditionalUserInfo", "FacebookAdditionalUserInfo", "GithubAdditionalUserInfo", "GoogleAdditionalUserInfo", "TwitterAdditionalUserInfo", "FederatedAdditionalUserInfoWithUsername", "getAdditionalUserInfo", "setPersistence", "initializeRecaptchaConfig", "validatePassword", "onIdTokenChanged", "beforeAuthStateChanged", "onAuthStateChanged", "useDeviceLanguage", "updateCurrentUser", "signOut", "revokeAccessToken", "deleteUser", "MultiFactorSessionImpl", "MultiFactorResolverImpl", "getMultiFactorResolver", "startEnrollTotpMfa", "finalizeEnrollTotpMfa", "withdrawMfa", "MultiFactorUserImpl", "multiFactorUserCache", "multiFactor", "AuthInterop", "getVersionForPlatform", "registerAuth", "_registerComponent", "Component", "registerVersion", "version", "getAuth", "getApp", "getDefaultEmulatorHost", "NOT_AVAILABLE_ERROR", "fail", "FailClass", "browserLocalPersistence", "browserSessionPersistence", "browserCookiePersistence", "indexedDBLocalPersistence", "browserPopupRedirectResolver", "PhoneAuthProvider", "reauthenticateWithPhoneNumber", "updatePhoneNumber", "signInWithPopup", "linkWithPopup", "reauthenticateWithPopup", "signInWithRedirect", "linkWithRedirect", "reauthenticateWithRedirect", "getRedirectResult", "RecaptchaVerifier", "PhoneMultiFactorGenerator", "finalizeSignInTotpMfa", "MultiFactorAssertionImpl", "TotpMultiFactorGenerator", "TotpMultiFactorAssertionImpl", "TotpSecret", "_isEmptyString", "exports", "require_index_cjs", "exports", "auth", "import_obsidian", "init_dist", "import_obsidian", "app", "init_dist", "init_dist", "version", "init_dist", "app", "name", "import_obsidian", "app", "functions", "httpsCallable", "FingerprintJS", "functions", "httpsCallable", "auth", "signInWithCustomToken", "onAuthStateChanged"]
}
