{"version":3,"sources":["../node_modules/@emotion/core/dist/emotion-element-04d85134.browser.esm.js","../node_modules/@emotion/css/dist/css.browser.esm.js","../node_modules/@emotion/core/dist/core.browser.esm.js","../node_modules/@babel/runtime/helpers/esm/createSuper.js","../node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","../node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","../node_modules/@babel/runtime/helpers/esm/iterableToArray.js","../node_modules/@emotion/sheet/dist/sheet.browser.esm.js","../node_modules/@emotion/unitless/dist/unitless.browser.esm.js","../node_modules/@emotion/memoize/dist/memoize.browser.esm.js","../node_modules/@babel/runtime/helpers/esm/toArray.js","../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../node_modules/@babel/runtime/helpers/esm/objectSpread.js","../node_modules/@babel/runtime/helpers/typeof.js","../node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js","../node_modules/@babel/runtime/helpers/esm/objectSpread2.js","../../src/crypt.ts","../../src/deepCopy.ts","../../src/deferred.ts","../../src/environment.ts","../../src/errors.ts","../../src/obj.ts","../../src/sha1.ts","../../src/subscribe.ts","../../src/exponential_backoff.ts","../node_modules/@babel/runtime/helpers/esm/slicedToArray.js","../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/defineProperty.js","../node_modules/@firebase/installations/node_modules/tslib/tslib.es6.js","../../src/util/errors.ts","../../src/util/constants.ts","../../src/api/common.ts","../../src/api/create-installation-request.ts","../../src/util/sleep.ts","../../src/helpers/buffer-to-base64-url-safe.ts","../../src/helpers/generate-fid.ts","../../src/util/get-key.ts","../../src/helpers/fid-changed.ts","../../src/helpers/idb-manager.ts","../../src/index.ts","../../src/helpers/get-installation-entry.ts","../../src/api/generate-auth-token-request.ts","../../src/helpers/refresh-auth-token.ts","../../src/functions/get-token.ts","../../src/api/delete-installation-request.ts","../../src/functions/on-id-change.ts","../../src/helpers/extract-app-config.ts","../../src/functions/get-id.ts","../../src/functions/delete-installation.ts","../node_modules/@babel/runtime/helpers/esm/typeof.js","../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../node_modules/@firebase/util/node_modules/tslib/tslib.es6.js","../node_modules/@date-io/date-fns/build/index.esm.js","../node_modules/@emotion/is-prop-valid/dist/is-prop-valid.browser.esm.js","../node_modules/@babel/runtime/helpers/interopRequireWildcard.js","../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","../node_modules/@babel/runtime/helpers/inheritsLoose.js","../node_modules/@babel/runtime/helpers/setPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/extends.js","../node_modules/@babel/runtime/helpers/toPropertyKey.js","../node_modules/@babel/runtime/helpers/toPrimitive.js","../node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js","../node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","../node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","../node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","../node_modules/@firebase/component/node_modules/tslib/tslib.es6.js","../../src/component.ts","../../src/provider.ts","../../src/constants.ts","../../src/component_container.ts","../node_modules/@firebase/messaging/node_modules/tslib/tslib.es6.js","../../src/interfaces/internal-message-payload.ts","../../src/helpers/array-base64-translator.ts","../../src/helpers/migrate-old-database.ts","../../src/core/api.ts","../../src/core/token-management.ts","../../src/helpers/is-console-message.ts","../../src/helpers/sleep.ts","../../src/controllers/sw-controller.ts","../../src/helpers/externalizePayload.ts","../../src/controllers/window-controller.ts","../node_modules/@firebase/analytics/node_modules/tslib/tslib.es6.js","../../src/logger.ts","../../src/helpers.ts","../../src/get-config.ts","../../src/initialize-ids.ts","../../src/factory.ts","../../src/functions.ts","../../index.ts","../node_modules/@firebase/app/node_modules/tslib/tslib.es6.js","../../src/firebaseApp.ts","../../src/firebaseNamespace.ts","../../src/firebaseNamespaceCore.ts","../../src/platformLoggerService.ts","../../src/registerCoreComponents.ts","../node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","../node_modules/@emotion/hash/dist/hash.browser.esm.js","../node_modules/@emotion/serialize/dist/serialize.browser.esm.js","../node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","../node_modules/@emotion/utils/dist/utils.browser.esm.js","../node_modules/@babel/runtime/helpers/extends.js","../node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","../node_modules/@babel/runtime/helpers/objectWithoutProperties.js","../node_modules/@babel/runtime/helpers/esm/defineProperty.js","../node_modules/@emotion/stylis/dist/stylis.browser.esm.js","../node_modules/@emotion/cache/dist/cache.browser.esm.js","../node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/esm/createClass.js","../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../node_modules/@babel/runtime/helpers/interopRequireDefault.js","../node_modules/@babel/runtime/helpers/esm/inherits.js"],"names":["hasOwnProperty","Object","prototype","EmotionCacheContext","createContext","HTMLElement","createCache","ThemeContext","withEmotionCache","Provider","func","render","props","ref","createElement","Consumer","cache","forwardRef","typePropName","createEmotionProps","type","newProps","key","call","Noop","theme","cssProp","css","undefined","registered","registeredStyles","className","getRegisteredStyles","serialized","serializeStyles","insertStyles","name","ele","possiblyStyleElement","Fragment","Emotion","_len","arguments","length","args","Array","_key","jsx","apply","argsLength","createElementArgArray","i","keyframes","Component","insertable","styles","anim","toString","this","classnames","len","cls","arg","toAdd","isArray","k","merge","rawClassName","context","content","cx","_len2","_key2","children","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Boolean","valueOf","e","result","Super","getPrototypeOf","NewTarget","constructor","possibleConstructorReturn","_setPrototypeOf","o","p","setPrototypeOf","bind","__proto__","_arrayWithHoles","arr","_nonIterableRest","TypeError","_iterableToArray","iter","Symbol","iterator","from","StyleSheet","options","isSpeedy","speedy","tags","ctr","nonce","container","before","_proto","insert","rule","_tag","tag","document","setAttribute","appendChild","createTextNode","createStyleElement","nextSibling","insertBefore","push","sheet","styleSheets","ownerNode","sheetForTag","isImportRule","charCodeAt","insertRule","cssRules","process","flush","forEach","parentNode","removeChild","unitlessKeys","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","msGridRow","msGridRowSpan","msGridColumn","msGridColumnSpan","fontWeight","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","WebkitLineClamp","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","memoize","fn","_toArray","_toPropertyKey","input","hint","prim","toPrimitive","res","String","Number","_objectSpread","target","source","ownKeys","keys","getOwnPropertySymbols","filter","sym","getOwnPropertyDescriptor","enumerable","_typeof","obj","module","exports","__esModule","_createForOfIteratorHelper","allowArrayLike","it","F","s","n","done","value","_e","f","err","normalCompletion","didErr","step","next","_e2","object","enumerableOnly","symbols","_objectSpread2","getOwnPropertyDescriptors","defineProperties","defineProperty","stringToByteArray","str","out","c","deepCopy","deepExtend","Date","getTime","prop","reject","resolve","promise","Promise","wrapCallback","callback","error","catch","isNode","global","isBrowser","self","isBrowserExtension","runtime","chrome","browser","id","isIndexedDBAvailable","indexedDB","validateIndexedDBOpenable","window","open","onsuccess","close","deleteDatabase","onupgradeneeded","onerror","message","areCookiesEnabled","navigator","cookieEnabled","contains","chain_","buf_","W_","pad_","inbuf_","total_","blockSize","reset","compress_","buf","offset","W","t","a","b","d","update","bytes","lengthMinusBlock","inbuf","digest","totalBits","j","createSubscribe","executor","onNoObservers","proxy","ObserverProxy","subscribe","observers","unsubscribes","observerCount","task","finalized","then","forEachObserver","observer","complete","nextOrObserver","Error","methods","method","implementsAnyMethods","noop","unsub","unsubscribeOne","finalError","sendOne","console","calculateBackoffMillis","backoffCount","intervalMillis","backoffFactor","currBaseValue","Math","pow","randomWait","round","random","min","_slicedToArray","arrayWithHoles","_i","_s","_x","_r","_arr","_n","_d","unsupportedIterableToArray","nonIterableRest","toPropertyKey","configurable","writable","__assign","assign","__awaiter","thisArg","_arguments","P","generator","fulfilled","rejected","__generator","body","y","g","_","label","sent","trys","ops","verb","v","op","pop","__values","m","__read","r","ar","getInstallationsEndpoint","INSTALLATIONS_API_URL","extractAuthTokenInfoFromResponse","response","token","requestStatus","expiresIn","responseExpiresIn","replace","creationTime","now","getErrorFromResponse","requestName","json","responseJson","errorData","ERROR_FACTORY","create","serverCode","code","serverMessage","serverStatus","status","getHeaders","apiKey","Headers","Accept","getHeadersWithAuth","appConfig","refreshToken","headers","append","INTERNAL_AUTH_VERSION","getAuthorizationHeader","retryIfServerError","createInstallationRequest","fid","endpoint","authVersion","appId","sdkVersion","request","JSON","stringify","fetch","ok","responseValue","registrationStatus","authToken","sleep","ms","setTimeout","bufferToBase64UrlSafe","array","btoa","fromCharCode","concat","VALID_FID_PATTERN","generateFid","fidByteArray","Uint8Array","crypto","msCrypto","getRandomValues","substr","encode","test","getKey","appName","fidChangeCallbacks","Map","fidChanged","callFidChangeCallbacks","channel","getBroadcastChannel","postMessage","closeBroadcastChannel","broadcastFidChange","callbacks","get","broadcastChannel","BroadcastChannel","onmessage","data","size","oldVersion","createObjectStore","OBJECT_STORE_NAME","dbPromise","getInstallationEntry","oldEntry","installationEntry","clearTimedOutRequest","updateOrCreateInstallationEntry","entryWithPromise","onLine","registrationPromiseWithError","registrationPromise","inProgressEntry","registrationTime","registeredInstallationEntry","set","isServerError","customData","remove","registerInstallation","waitUntilFidRegistration","triggerRegistrationIfNecessary","updateInstallationRequest","entry","generateAuthTokenRequest","platformLoggerProvider","getGenerateAuthTokenEndpoint","platformLogger","getImmediate","optional","getPlatformInfoString","installation","refreshAuthToken","dependencies","forceRefresh","isEntryRegistered","oldAuthToken","isAuthTokenExpired","isAuthTokenValid","tokenPromise","updateAuthTokenRequest","waitUntilAuthTokenRequest","inProgressAuthToken","requestTime","makeAuthTokenRequestInProgressEntry","updatedInstallationEntry","fetchAuthTokenFromServer","completeInstallationRegistration","deleteInstallationRequest","getDeleteEndpoint","callbackSet","Set","add","addCallback","delete","removeCallback","_objectWithoutPropertiesLoose","excluded","sourceKeys","indexOf","extendStatics","__extends","__","DateFnsUtils","_a","locale","yearFormat","yearMonthFormat","dateTime12hFormat","dateTime24hFormat","time12hFormat","time24hFormat","dateFormat","addDays","count","isValid","date","getDiff","comparing","differenceInMilliseconds","isAfter","isBefore","startOfDay","endOfDay","getHours","setHours","setMinutes","getSeconds","setSeconds","isSameDay","isSameMonth","isSameYear","isSameHour","startOfMonth","endOfMonth","getYear","setYear","parse","formatString","dateFnsParse","format","isEqual","isNull","isAfterDay","isBeforeDay","isBeforeYear","startOfYear","isAfterYear","endOfYear","formatNumber","numberToFormat","getMinutes","getMonth","setMonth","getMeridiemText","ampm","getNextMonth","addMonths","getPreviousMonth","getMonthArray","monthArray","prevMonth","mergeDateAndTime","time","getWeekdays","_this","eachDayOfInterval","start","startOfWeek","end","endOfWeek","map","day","getWeekArray","current","nestedWeeks","weekNumber","floor","getYearRange","startDate","endDate","years","addYears","getCalendarHeaderText","getYearText","getDatePickerHeaderText","getDateTimePickerHeaderText","getMonthText","getDayText","getHourText","getMinuteText","getSecondText","reactPropsRegex","index","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","has","newObj","hasPropertyDescriptor","desc","_inheritsLoose","subClass","superClass","_extends","_toConsumableArray","arrayLikeToArray","iterableToArray","__spread","instanceFactory","multipleInstances","serviceProps","instantiationMode","setInstantiationMode","mode","setMultipleInstances","setServiceProps","component","instances","instancesDeferred","identifier","normalizedIdentifier","normalizeInstanceIdentifier","deferred","instance","getOrInitializeService","getComponent","setComponent","isComponentEager","entries","instanceIdentifier","instanceDeferred","clearInstance","services","values","all","service","INTERNAL","_delete","isComponentSet","normalizeIdentifierForFactory","providers","addComponent","provider","getProvider","addOrOverwriteComponent","getProviders","MessageType","ERROR_MAP","DEFAULT_VAPID_KEY","arrayToBase64","uint8Array","base64ToArray","base64String","base64","repeat","rawData","atob","outputArray","migrateOldDatabase","senderId","databases","db","includes","tokenDetails","objectStoreNames","objectStore","transaction","clear","oldDetails","auth","p256dh","fcmToken","createTime","subscriptionOptions","swScope","vapidKey","checkTokenDetails","getDbPromise","upgradeDb","dbGet","firebaseDependencies","oldTokenDetails","dbSet","tx","put","dbRemove","requestGetToken","getBody","subscribeOptions","getEndpoint","responseData","errorInfo","requestUpdateToken","updateOptions","requestDeleteToken","unsubscribeOptions","ENDPOINT","installations","getToken","web","applicationPubKey","swRegistration","Notification","permission","getPushSubscription","pushSubscription","scope","getNewToken","dbOptions","currentOptions","isVapidKeyEqual","isEndpointEqual","isAuthEqual","isP256dhEqual","isTokenValid","warn","updateToken","deleteToken","pushManager","getSubscription","unsubscribe","updatedToken","updatedTokenDetails","subscription","userVisibleOnly","applicationServerKey","isConsoleMessage","isOnBackgroundMessageUsed","bgMessageHandler","addEventListener","waitUntil","onPush","onSubChange","onNotificationClick","app","setBackgroundMessageHandler","onBackgroundMessage","registration","requestPermission","usePublicVapidKey","useServiceWorker","onMessage","onTokenRefresh","event","internalPayload","getMessagePayloadInternal","getClientList","debug","TAG","clientList","some","client","visibilityState","url","startsWith","hasVisibleClients","sendMessagePayloadInternalToWindows","isNotificationShown","notification","showNotification","wrapInternalPayload","payload","collapseKey","collapse_key","messagePayloadInternal","title","image","propagateNotificationPayload","propagateDataPayload","fcmOptions","link","analyticsLabel","analytics_label","propagateFcmOptions","externalizePayload","action","stopImmediatePropagation","click_action","location","origin","getLink","URL","href","originUrl","host","getWindowClient","clients","openWindow","focus","messageType","NOTIFICATION_CLICKED","isFirebaseMessaging","wrappedInternalPayload","clientUrl","PUSH_RECEIVED","matchAll","includeUncontrolled","notificationPayloadInternal","actions","maxActions","onMessageCallback","serviceWorker","messageEventListener","stripInternalFields","dataPayload","logEvent","getVapidKey","getSwReg","updateVapidKey","updateSwReg","serviceWorkerRegistration","registerDefaultSw","ServiceWorkerRegistration","register","browserErrorMessage","permissionResult","eventType","getEventType","analyticsProvider","message_id","message_name","message_time","message_device_time","getMissingValueError","valueName","NAMESPACE_EXPORTS","isSupported","PushSubscription","registerComponent","keyName","projectId","messagingSenderId","extractAppConfig","gtagOnConfig","gtagCore","initializationPromisesMap","dynamicConfigPromisesList","measurementIdToAppId","measurementId","gtagParams","correspondingAppId","dynamicConfigResults","foundConfig","find","config","logger","GtagCommand","CONFIG","gtagOnEvent","initializationPromisesToWaitFor","gaSendToList","sendToId","initializationPromise","EVENT","wrapOrCreateGtag","dataLayerName","gtagFunctionName","command","idOrNameOrParams","SET","wrapGtag","wrappedGtag","defaultRetryData","throttleMetadata","getThrottleMetadata","setThrottleMetadata","metadata","deleteThrottleMetadata","fetchDynamicConfig","appFields","appUrl","errorMessage","jsonResponse","httpStatus","responseMessage","attemptFetchDynamicConfigWithRetry","signal","retryData","throttleEndTimeMillis","setAbortableTimeout","isRetriableError","backoffMillis","max","timeout","clearTimeout","listeners","listener","abort","initializeIds","dynamicConfigPromise","timeoutMillis","AnalyticsAbortSignal","fetchDynamicConfigWithRetry","fidPromise","validateIndexedDB","envIsValid","getId","dynamicConfig","configProperties","gtagCoreFunction","wrappedGtagFunction","gtagName","globalInitDone","settings","factory","mismatchedEnvMessages","details","join","warnOnBrowserContextMismatch","scriptTags","getElementsByTagName","src","GTAG_URL","findGtagScriptOnPage","script","async","head","insertScriptTag","dataLayer","getOrCreateDataLayer","eventName","eventParams","gtagFunction","params","setCurrentScreen","screenName","setUserId","setUserProperties","properties","flatProperties","setAnalyticsCollectionEnabled","enabled","ERRORS","PLATFORM_LOG_STRING","firebase_","isDeleted_","name_","automaticDataCollectionEnabled_","automaticDataCollectionEnabled","options_","_addComponent","components","checkDestroyed_","val","removeApp","_getService","_removeServiceInstance","_addOrOverwriteComponent","log","createFirebaseNamespace","namespace","firebaseAppImpl","apps","initializeApp","rawConfig","registerVersion","libraryKeyOrName","version","variant","library","libraryMismatch","match","versionMismatch","warning","setLogLevel","onLog","logCallback","SDK_VERSION","useAsService","componentName","serviceNamespace","appArg","serviceFxn","createFirebaseNamespaceCore","extendNamespace","ErrorFactory","isVersionServiceProvider","logString","firebase","firebaseNamespace","PlatformLoggerService","_getPrototypeOf","murmur2","h","hyphenateRegex","animationRegex","isCustomProperty","property","isProcessableValue","processStyleName","styleName","toLowerCase","processStyleValue","p1","p2","cursor","unitless","handleInterpolation","mergedProps","interpolation","couldBeSelectorInterpolation","__emotion_styles","string","interpolated","createStringFromObject","previousCursor","cached","labelPattern","stringMode","strings","raw","lastIndex","identifierName","exec","hashString","_possibleConstructorReturn","classNames","split","isStringTag","inserted","_objectWithoutProperties","sourceSymbolKeys","propertyIsEnumerable","_unsupportedIterableToArray","minLen","slice","objectWithoutPropertiesLoose","_defineProperty","LogLevel","levelStringToEnum","DEBUG","VERBOSE","INFO","WARN","ERROR","SILENT","defaultLogLevel","ConsoleMethod","defaultLogHandler","logType","logLevel","toISOString","_logLevel","_logHandler","_userLogHandler","info","level","inst","setUserLogHandler","customLogLevel","userLogHandler","ignored","stylis_min","X","trim","ia","Z","substring","w","L","ja","ka","aa","G","ba","la","ma","R","na","ea","oa","H","q","x","A","S","B","U","prefix","D","z","M","C","K","u","l","I","J","N","charAt","ca","O","da","fa","Y","E","ha","Q","use","T","toSheet","block","Sheet","ruleSheet","selectors","parents","line","column","ns","depth","at","delimiter","stylisOptions","stylis","Stylis","_insert","nodes","querySelectorAll","node","getAttribute","stylisPlugins","selector","shouldCache","_assertThisInitialized","ReferenceError","_arrayLikeToArray","arr2","_defineProperties","descriptor","_createClass","Constructor","protoProps","staticProps","_classCallCheck","_inherits"],"mappings":"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","file":"static/js/main~748942c6.64e17854.chunk.js","sourcesContent":["import '@babel/runtime/helpers/inheritsLoose';\nimport { createContext, forwardRef, createElement, Fragment } from 'react';\nimport createCache from '@emotion/cache';\nimport { getRegisteredStyles, insertStyles } from '@emotion/utils';\nimport { serializeStyles } from '@emotion/serialize';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar EmotionCacheContext = /*#__PURE__*/createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case\n// because this module is primarily intended for the browser and node\n// but it's also required in react native and similar environments sometimes\n// and we could have a special build just for that\n// but this is much easier and the native packages\n// might use a different theme context in the future anyway\ntypeof HTMLElement !== 'undefined' ? createCache() : null);\nvar ThemeContext = /*#__PURE__*/createContext({});\nvar CacheProvider = EmotionCacheContext.Provider;\n\nvar withEmotionCache = function withEmotionCache(func) {\n  var render = function render(props, ref) {\n    return /*#__PURE__*/createElement(EmotionCacheContext.Consumer, null, function (cache) {\n      return func(props, cache, ref);\n    });\n  }; // $FlowFixMe\n\n\n  return /*#__PURE__*/forwardRef(render);\n};\n\n// thus we only need to replace what is a valid character for JS, but not for CSS\n\nvar sanitizeIdentifier = function sanitizeIdentifier(identifier) {\n  return identifier.replace(/\\$/g, '-');\n};\n\nvar typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';\nvar labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';\nvar createEmotionProps = function createEmotionProps(type, props) {\n  if (process.env.NODE_ENV !== 'production' && typeof props.css === 'string' && // check if there is a css declaration\n  props.css.indexOf(':') !== -1) {\n    throw new Error(\"Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/css' like this: css`\" + props.css + \"`\");\n  }\n\n  var newProps = {};\n\n  for (var key in props) {\n    if (hasOwnProperty.call(props, key)) {\n      newProps[key] = props[key];\n    }\n  }\n\n  newProps[typePropName] = type; // TODO: check if this still works with all of those different JSX functions\n\n  if (process.env.NODE_ENV !== 'production') {\n    var error = new Error();\n\n    if (error.stack) {\n      // chrome\n      var match = error.stack.match(/at (?:Object\\.|Module\\.|)(?:jsx|createEmotionProps).*\\n\\s+at (?:Object\\.|)([A-Z][A-Za-z$]+) /);\n\n      if (!match) {\n        // safari and firefox\n        match = error.stack.match(/.*\\n([A-Z][A-Za-z$]+)@/);\n      }\n\n      if (match) {\n        newProps[labelPropName] = sanitizeIdentifier(match[1]);\n      }\n    }\n  }\n\n  return newProps;\n};\n\nvar Noop = function Noop() {\n  return null;\n};\n\nvar render = function render(cache, props, theme, ref) {\n  var cssProp = theme === null ? props.css : props.css(theme); // so that using `css` from `emotion` and passing the result to the css prop works\n  // not passing the registered cache to serializeStyles because it would\n  // make certain babel optimisations not possible\n\n  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {\n    cssProp = cache.registered[cssProp];\n  }\n\n  var type = props[typePropName];\n  var registeredStyles = [cssProp];\n  var className = '';\n\n  if (typeof props.className === 'string') {\n    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);\n  } else if (props.className != null) {\n    className = props.className + \" \";\n  }\n\n  var serialized = serializeStyles(registeredStyles);\n\n  if (process.env.NODE_ENV !== 'production' && serialized.name.indexOf('-') === -1) {\n    var labelFromStack = props[labelPropName];\n\n    if (labelFromStack) {\n      serialized = serializeStyles([serialized, 'label:' + labelFromStack + ';']);\n    }\n  }\n\n  var rules = insertStyles(cache, serialized, typeof type === 'string');\n  className += cache.key + \"-\" + serialized.name;\n  var newProps = {};\n\n  for (var key in props) {\n    if (hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && (process.env.NODE_ENV === 'production' || key !== labelPropName)) {\n      newProps[key] = props[key];\n    }\n  }\n\n  newProps.ref = ref;\n  newProps.className = className;\n  var ele = /*#__PURE__*/createElement(type, newProps);\n  var possiblyStyleElement = /*#__PURE__*/createElement(Noop, null);\n\n\n  return /*#__PURE__*/createElement(Fragment, null, possiblyStyleElement, ele);\n}; // eslint-disable-next-line no-undef\n\n\nvar Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {\n  if (typeof props.css === 'function') {\n    return /*#__PURE__*/createElement(ThemeContext.Consumer, null, function (theme) {\n      return render(cache, props, theme, ref);\n    });\n  }\n\n  return render(cache, props, null, ref);\n});\n\nif (process.env.NODE_ENV !== 'production') {\n  Emotion.displayName = 'EmotionCssPropInternal';\n}\n\nexport { CacheProvider as C, Emotion as E, ThemeContext as T, createEmotionProps as c, hasOwnProperty as h, withEmotionCache as w };\n","import { serializeStyles } from '@emotion/serialize';\n\nfunction css() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  return serializeStyles(args);\n}\n\nexport default css;\n","import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport { createElement, Component, Fragment } from 'react';\nimport '@emotion/cache';\nimport { h as hasOwnProperty, E as Emotion, c as createEmotionProps, w as withEmotionCache, T as ThemeContext } from './emotion-element-04d85134.browser.esm.js';\nexport { C as CacheProvider, T as ThemeContext, w as withEmotionCache } from './emotion-element-04d85134.browser.esm.js';\nimport { insertStyles, getRegisteredStyles } from '@emotion/utils';\nimport { serializeStyles } from '@emotion/serialize';\nimport { StyleSheet } from '@emotion/sheet';\nimport css from '@emotion/css';\nexport { default as css } from '@emotion/css';\n\nvar jsx = function jsx(type, props) {\n  var args = arguments;\n\n  if (props == null || !hasOwnProperty.call(props, 'css')) {\n    // $FlowFixMe\n    return createElement.apply(undefined, args);\n  }\n\n  var argsLength = args.length;\n  var createElementArgArray = new Array(argsLength);\n  createElementArgArray[0] = Emotion;\n  createElementArgArray[1] = createEmotionProps(type, props);\n\n  for (var i = 2; i < argsLength; i++) {\n    createElementArgArray[i] = args[i];\n  } // $FlowFixMe\n\n\n  return createElement.apply(null, createElementArgArray);\n};\n\nvar warnedAboutCssPropForGlobal = false;\nvar Global = /* #__PURE__ */withEmotionCache(function (props, cache) {\n  if (process.env.NODE_ENV !== 'production' && !warnedAboutCssPropForGlobal && ( // check for className as well since the user is\n  // probably using the custom createElement which\n  // means it will be turned into a className prop\n  // $FlowFixMe I don't really want to add it to the type since it shouldn't be used\n  props.className || props.css)) {\n    console.error(\"It looks like you're using the css prop on Global, did you mean to use the styles prop instead?\");\n    warnedAboutCssPropForGlobal = true;\n  }\n\n  var styles = props.styles;\n\n  if (typeof styles === 'function') {\n    return /*#__PURE__*/createElement(ThemeContext.Consumer, null, function (theme) {\n      var serialized = serializeStyles([styles(theme)]);\n      return /*#__PURE__*/createElement(InnerGlobal, {\n        serialized: serialized,\n        cache: cache\n      });\n    });\n  }\n\n  var serialized = serializeStyles([styles]);\n  return /*#__PURE__*/createElement(InnerGlobal, {\n    serialized: serialized,\n    cache: cache\n  });\n});\n\n// maintain place over rerenders.\n// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild\n// initial client-side render from SSR, use place of hydrating tag\nvar InnerGlobal = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(InnerGlobal, _React$Component);\n\n  function InnerGlobal(props, context, updater) {\n    return _React$Component.call(this, props, context, updater) || this;\n  }\n\n  var _proto = InnerGlobal.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    this.sheet = new StyleSheet({\n      key: this.props.cache.key + \"-global\",\n      nonce: this.props.cache.sheet.nonce,\n      container: this.props.cache.sheet.container\n    }); // $FlowFixMe\n\n    var node = document.querySelector(\"style[data-emotion-\" + this.props.cache.key + \"=\\\"\" + this.props.serialized.name + \"\\\"]\");\n\n    if (node !== null) {\n      this.sheet.tags.push(node);\n    }\n\n    if (this.props.cache.sheet.tags.length) {\n      this.sheet.before = this.props.cache.sheet.tags[0];\n    }\n\n    this.insertStyles();\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (prevProps.serialized.name !== this.props.serialized.name) {\n      this.insertStyles();\n    }\n  };\n\n  _proto.insertStyles = function insertStyles$1() {\n    if (this.props.serialized.next !== undefined) {\n      // insert keyframes\n      insertStyles(this.props.cache, this.props.serialized.next, true);\n    }\n\n    if (this.sheet.tags.length) {\n      // if this doesn't exist then it will be null so the style element will be appended\n      var element = this.sheet.tags[this.sheet.tags.length - 1].nextElementSibling;\n      this.sheet.before = element;\n      this.sheet.flush();\n    }\n\n    this.props.cache.insert(\"\", this.props.serialized, this.sheet, false);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.sheet.flush();\n  };\n\n  _proto.render = function render() {\n\n    return null;\n  };\n\n  return InnerGlobal;\n}(Component);\n\nvar keyframes = function keyframes() {\n  var insertable = css.apply(void 0, arguments);\n  var name = \"animation-\" + insertable.name; // $FlowFixMe\n\n  return {\n    name: name,\n    styles: \"@keyframes \" + name + \"{\" + insertable.styles + \"}\",\n    anim: 1,\n    toString: function toString() {\n      return \"_EMO_\" + this.name + \"_\" + this.styles + \"_EMO_\";\n    }\n  };\n};\n\nvar classnames = function classnames(args) {\n  var len = args.length;\n  var i = 0;\n  var cls = '';\n\n  for (; i < len; i++) {\n    var arg = args[i];\n    if (arg == null) continue;\n    var toAdd = void 0;\n\n    switch (typeof arg) {\n      case 'boolean':\n        break;\n\n      case 'object':\n        {\n          if (Array.isArray(arg)) {\n            toAdd = classnames(arg);\n          } else {\n            toAdd = '';\n\n            for (var k in arg) {\n              if (arg[k] && k) {\n                toAdd && (toAdd += ' ');\n                toAdd += k;\n              }\n            }\n          }\n\n          break;\n        }\n\n      default:\n        {\n          toAdd = arg;\n        }\n    }\n\n    if (toAdd) {\n      cls && (cls += ' ');\n      cls += toAdd;\n    }\n  }\n\n  return cls;\n};\n\nfunction merge(registered, css, className) {\n  var registeredStyles = [];\n  var rawClassName = getRegisteredStyles(registered, registeredStyles, className);\n\n  if (registeredStyles.length < 2) {\n    return className;\n  }\n\n  return rawClassName + css(registeredStyles);\n}\n\nvar Noop = function Noop() {\n  return null;\n};\n\nvar ClassNames = withEmotionCache(function (props, context) {\n  return /*#__PURE__*/createElement(ThemeContext.Consumer, null, function (theme) {\n    var hasRendered = false;\n\n    var css = function css() {\n      if (hasRendered && process.env.NODE_ENV !== 'production') {\n        throw new Error('css can only be used during render');\n      }\n\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n\n      var serialized = serializeStyles(args, context.registered);\n\n      {\n        insertStyles(context, serialized, false);\n      }\n\n      return context.key + \"-\" + serialized.name;\n    };\n\n    var cx = function cx() {\n      if (hasRendered && process.env.NODE_ENV !== 'production') {\n        throw new Error('cx can only be used during render');\n      }\n\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      return merge(context.registered, css, classnames(args));\n    };\n\n    var content = {\n      css: css,\n      cx: cx,\n      theme: theme\n    };\n    var ele = props.children(content);\n    hasRendered = true;\n    var possiblyStyleElement = /*#__PURE__*/createElement(Noop, null);\n\n\n    return /*#__PURE__*/createElement(Fragment, null, possiblyStyleElement, ele);\n  });\n});\n\nexport { ClassNames, Global, jsx as createElement, jsx, keyframes };\n","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nimport possibleConstructorReturn from \"./possibleConstructorReturn.js\";\nexport default function _createSuper(Derived) {\n  var hasNativeReflectConstruct = isNativeReflectConstruct();\n  return function _createSuperInternal() {\n    var Super = getPrototypeOf(Derived),\n      result;\n    if (hasNativeReflectConstruct) {\n      var NewTarget = getPrototypeOf(this).constructor;\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n    return possibleConstructorReturn(this, result);\n  };\n}","export default function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n  return _setPrototypeOf(o, p);\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","/*\n\nBased off glamor's StyleSheet, thanks Sunil ❤️\n\nhigh performance StyleSheet for css-in-js systems\n\n- uses multiple style tags behind the scenes for millions of rules\n- uses `insertRule` for appending in production for *much* faster performance\n\n// usage\n\nimport { StyleSheet } from '@emotion/sheet'\n\nlet styleSheet = new StyleSheet({ key: '', container: document.head })\n\nstyleSheet.insert('#box { border: 1px solid red; }')\n- appends a css rule into the stylesheet\n\nstyleSheet.flush()\n- empties the stylesheet of all its contents\n\n*/\n// $FlowFixMe\nfunction sheetForTag(tag) {\n  if (tag.sheet) {\n    // $FlowFixMe\n    return tag.sheet;\n  } // this weirdness brought to you by firefox\n\n  /* istanbul ignore next */\n\n\n  for (var i = 0; i < document.styleSheets.length; i++) {\n    if (document.styleSheets[i].ownerNode === tag) {\n      // $FlowFixMe\n      return document.styleSheets[i];\n    }\n  }\n}\n\nfunction createStyleElement(options) {\n  var tag = document.createElement('style');\n  tag.setAttribute('data-emotion', options.key);\n\n  if (options.nonce !== undefined) {\n    tag.setAttribute('nonce', options.nonce);\n  }\n\n  tag.appendChild(document.createTextNode(''));\n  return tag;\n}\n\nvar StyleSheet =\n/*#__PURE__*/\nfunction () {\n  function StyleSheet(options) {\n    this.isSpeedy = options.speedy === undefined ? process.env.NODE_ENV === 'production' : options.speedy;\n    this.tags = [];\n    this.ctr = 0;\n    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets\n\n    this.key = options.key;\n    this.container = options.container;\n    this.before = null;\n  }\n\n  var _proto = StyleSheet.prototype;\n\n  _proto.insert = function insert(rule) {\n    // the max length is how many rules we have per style tag, it's 65000 in speedy mode\n    // it's 1 in dev because we insert source maps that map a single rule to a location\n    // and you can only have one source map per style tag\n    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {\n      var _tag = createStyleElement(this);\n\n      var before;\n\n      if (this.tags.length === 0) {\n        before = this.before;\n      } else {\n        before = this.tags[this.tags.length - 1].nextSibling;\n      }\n\n      this.container.insertBefore(_tag, before);\n      this.tags.push(_tag);\n    }\n\n    var tag = this.tags[this.tags.length - 1];\n\n    if (this.isSpeedy) {\n      var sheet = sheetForTag(tag);\n\n      try {\n        // this is a really hot path\n        // we check the second character first because having \"i\"\n        // as the second character will happen less often than\n        // having \"@\" as the first character\n        var isImportRule = rule.charCodeAt(1) === 105 && rule.charCodeAt(0) === 64; // this is the ultrafast version, works across browsers\n        // the big drawback is that the css won't be editable in devtools\n\n        sheet.insertRule(rule, // we need to insert @import rules before anything else\n        // otherwise there will be an error\n        // technically this means that the @import rules will\n        // _usually_(not always since there could be multiple style tags)\n        // be the first ones in prod and generally later in dev\n        // this shouldn't really matter in the real world though\n        // @import is generally only used for font faces from google fonts and etc.\n        // so while this could be technically correct then it would be slower and larger\n        // for a tiny bit of correctness that won't matter in the real world\n        isImportRule ? 0 : sheet.cssRules.length);\n      } catch (e) {\n        if (process.env.NODE_ENV !== 'production') {\n          console.warn(\"There was a problem inserting the following rule: \\\"\" + rule + \"\\\"\", e);\n        }\n      }\n    } else {\n      tag.appendChild(document.createTextNode(rule));\n    }\n\n    this.ctr++;\n  };\n\n  _proto.flush = function flush() {\n    // $FlowFixMe\n    this.tags.forEach(function (tag) {\n      return tag.parentNode.removeChild(tag);\n    });\n    this.tags = [];\n    this.ctr = 0;\n  };\n\n  return StyleSheet;\n}();\n\nexport { StyleSheet };\n","var unitlessKeys = {\n  animationIterationCount: 1,\n  borderImageOutset: 1,\n  borderImageSlice: 1,\n  borderImageWidth: 1,\n  boxFlex: 1,\n  boxFlexGroup: 1,\n  boxOrdinalGroup: 1,\n  columnCount: 1,\n  columns: 1,\n  flex: 1,\n  flexGrow: 1,\n  flexPositive: 1,\n  flexShrink: 1,\n  flexNegative: 1,\n  flexOrder: 1,\n  gridRow: 1,\n  gridRowEnd: 1,\n  gridRowSpan: 1,\n  gridRowStart: 1,\n  gridColumn: 1,\n  gridColumnEnd: 1,\n  gridColumnSpan: 1,\n  gridColumnStart: 1,\n  msGridRow: 1,\n  msGridRowSpan: 1,\n  msGridColumn: 1,\n  msGridColumnSpan: 1,\n  fontWeight: 1,\n  lineHeight: 1,\n  opacity: 1,\n  order: 1,\n  orphans: 1,\n  tabSize: 1,\n  widows: 1,\n  zIndex: 1,\n  zoom: 1,\n  WebkitLineClamp: 1,\n  // SVG-related properties\n  fillOpacity: 1,\n  floodOpacity: 1,\n  stopOpacity: 1,\n  strokeDasharray: 1,\n  strokeDashoffset: 1,\n  strokeMiterlimit: 1,\n  strokeOpacity: 1,\n  strokeWidth: 1\n};\n\nexport default unitlessKeys;\n","function memoize(fn) {\n  var cache = {};\n  return function (arg) {\n    if (cache[arg] === undefined) cache[arg] = fn(arg);\n    return cache[arg];\n  };\n}\n\nexport default memoize;\n","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _toArray(arr) {\n  return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import defineProperty from \"./defineProperty.js\";\nexport default function _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? Object(arguments[i]) : {};\n    var ownKeys = Object.keys(source);\n    if (typeof Object.getOwnPropertySymbols === 'function') {\n      ownKeys.push.apply(ownKeys, Object.getOwnPropertySymbols(source).filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n      }));\n    }\n    ownKeys.forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    });\n  }\n  return target;\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nexport default function _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      var F = function F() {};\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n  var normalCompletion = true,\n    didErr = false,\n    err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}","import defineProperty from \"./defineProperty.js\";\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nexport default function _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst stringToByteArray = function (str: string): number[] {\n  // TODO(user): Use native implementations if/when available\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (\n      (c & 0xfc00) === 0xd800 &&\n      i + 1 < str.length &&\n      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00\n    ) {\n      // Surrogate Pair\n      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes: number[]): string {\n  // TODO(user): Use native implementations if/when available\n  const out: string[] = [];\n  let pos = 0,\n    c = 0;\n  while (pos < bytes.length) {\n    const c1 = bytes[pos++];\n    if (c1 < 128) {\n      out[c++] = String.fromCharCode(c1);\n    } else if (c1 > 191 && c1 < 224) {\n      const c2 = bytes[pos++];\n      out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\n    } else if (c1 > 239 && c1 < 365) {\n      // Surrogate Pair\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      const c4 = bytes[pos++];\n      const u =\n        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n        0x10000;\n      out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n    } else {\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      out[c++] = String.fromCharCode(\n        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)\n      );\n    }\n  }\n  return out.join('');\n};\n\ninterface Base64 {\n  byteToCharMap_: { [key: number]: string } | null;\n  charToByteMap_: { [key: string]: number } | null;\n  byteToCharMapWebSafe_: { [key: number]: string } | null;\n  charToByteMapWebSafe_: { [key: string]: number } | null;\n  ENCODED_VALS_BASE: string;\n  readonly ENCODED_VALS: string;\n  readonly ENCODED_VALS_WEBSAFE: string;\n  HAS_NATIVE_SUPPORT: boolean;\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string;\n  encodeString(input: string, webSafe?: boolean): string;\n  decodeString(input: string, webSafe: boolean): string;\n  decodeStringToByteArray(input: string, webSafe: boolean): number[];\n  init_(): void;\n}\n\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\nexport const base64: Base64 = {\n  /**\n   * Maps bytes to characters.\n   */\n  byteToCharMap_: null,\n\n  /**\n   * Maps characters to bytes.\n   */\n  charToByteMap_: null,\n\n  /**\n   * Maps bytes to websafe characters.\n   * @private\n   */\n  byteToCharMapWebSafe_: null,\n\n  /**\n   * Maps websafe characters to bytes.\n   * @private\n   */\n  charToByteMapWebSafe_: null,\n\n  /**\n   * Our default alphabet, shared between\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n   */\n  ENCODED_VALS_BASE:\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n\n  /**\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n\n  /**\n   * Our websafe alphabet.\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n\n  /**\n   * Whether this browser supports the atob and btoa functions. This extension\n   * started at Mozilla but is now implemented by many browsers. We use the\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\n   * but still allowing the standard per-browser compilations.\n   *\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n\n  /**\n   * Base64-encode an array of bytes.\n   *\n   * @param input An array of bytes (numbers with\n   *     value in [0, 255]) to encode.\n   * @param webSafe Boolean indicating we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n\n    this.init_();\n\n    const byteToCharMap = webSafe\n      ? this.byteToCharMapWebSafe_!\n      : this.byteToCharMap_!;\n\n    const output = [];\n\n    for (let i = 0; i < input.length; i += 3) {\n      const byte1 = input[i];\n      const haveByte2 = i + 1 < input.length;\n      const byte2 = haveByte2 ? input[i + 1] : 0;\n      const haveByte3 = i + 2 < input.length;\n      const byte3 = haveByte3 ? input[i + 2] : 0;\n\n      const outByte1 = byte1 >> 2;\n      const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\n      let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\n      let outByte4 = byte3 & 0x3f;\n\n      if (!haveByte3) {\n        outByte4 = 64;\n\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n\n      output.push(\n        byteToCharMap[outByte1],\n        byteToCharMap[outByte2],\n        byteToCharMap[outByte3],\n        byteToCharMap[outByte4]\n      );\n    }\n\n    return output.join('');\n  },\n\n  /**\n   * Base64-encode a string.\n   *\n   * @param input A string to encode.\n   * @param webSafe If true, we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeString(input: string, webSafe?: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return btoa(input);\n    }\n    return this.encodeByteArray(stringToByteArray(input), webSafe);\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * @param input to decode.\n   * @param webSafe True if we should use the\n   *     alternative alphabet.\n   * @return string representing the decoded value.\n   */\n  decodeString(input: string, webSafe: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return atob(input);\n    }\n    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * In base-64 decoding, groups of four characters are converted into three\n   * bytes.  If the encoder did not apply padding, the input length may not\n   * be a multiple of 4.\n   *\n   * In this case, the last group will have fewer than 4 characters, and\n   * padding will be inferred.  If the group has one or two characters, it decodes\n   * to one byte.  If the group has three characters, it decodes to two bytes.\n   *\n   * @param input Input to decode.\n   * @param webSafe True if we should use the web-safe alphabet.\n   * @return bytes representing the decoded value.\n   */\n  decodeStringToByteArray(input: string, webSafe: boolean): number[] {\n    this.init_();\n\n    const charToByteMap = webSafe\n      ? this.charToByteMapWebSafe_!\n      : this.charToByteMap_!;\n\n    const output: number[] = [];\n\n    for (let i = 0; i < input.length; ) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw Error();\n      }\n\n      const outByte1 = (byte1 << 2) | (byte2 >> 4);\n      output.push(outByte1);\n\n      if (byte3 !== 64) {\n        const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n        output.push(outByte2);\n\n        if (byte4 !== 64) {\n          const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n\n    return output;\n  },\n\n  /**\n   * Lazy static initialization function. Called before\n   * accessing any of the static map variables.\n   * @private\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n\n      // We want quick mappings back and forth, so we precompute two maps.\n      for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n        this.charToByteMap_[this.byteToCharMap_[i]] = i;\n        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n\n        // Be forgiving when decoding and correctly decode both encodings.\n        if (i >= this.ENCODED_VALS_BASE.length) {\n          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n        }\n      }\n    }\n  }\n};\n\n/**\n * URL-safe base64 encoding\n */\nexport const base64Encode = function (str: string): string {\n  const utf8Bytes = stringToByteArray(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nexport const base64Decode = function (str: string): string | null {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\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 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport class Deferred<R> {\n  promise: Promise<R>;\n  reject: (value?: unknown) => void = () => {};\n  resolve: (value?: unknown) => void = () => {};\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve as (value?: unknown) => void;\n      this.reject = reject as (value?: unknown) => void;\n    });\n  }\n\n  /**\n   * Our API internals are not promiseified and cannot because our callback APIs have subtle expectations around\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\n   */\n  wrapCallback(\n    callback?: (error?: unknown, value?: unknown) => void\n  ): (error: unknown, value?: unknown) => void {\n    return (error, value?) => {\n      if (error) {\n        this.reject(error);\n      } else {\n        this.resolve(value);\n      }\n      if (typeof callback === 'function') {\n        // Attaching noop handler just in case developer wasn't expecting\n        // promises\n        this.promise.catch(() => {});\n\n        // Some of our callbacks don't expect a value and our own tests\n        // assert that the parameter length is 1\n        if (callback.length === 1) {\n          callback(error);\n        } else {\n          callback(error, value);\n        }\n      }\n    };\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\n\n/**\n * Returns navigator.userAgent string or '' if it's not defined.\n * @return user agent string\n */\nexport function getUA(): string {\n  if (\n    typeof navigator !== 'undefined' &&\n    typeof navigator['userAgent'] === 'string'\n  ) {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n\n/**\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\n *\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\n * wait for a callback.\n */\nexport function isMobileCordova(): boolean {\n  return (\n    typeof window !== 'undefined' &&\n    // @ts-ignore Setting up an broadly applicable index signature for Window\n    // just to deal with this case would probably be a bad idea.\n    !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&\n    /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA())\n  );\n}\n\n/**\n * Detect Node.js.\n *\n * @return true if Node.js environment is detected.\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nexport function isNode(): boolean {\n  try {\n    return (\n      Object.prototype.toString.call(global.process) === '[object process]'\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Detect Browser Environment\n */\nexport function isBrowser(): boolean {\n  return typeof self === 'object' && self.self === self;\n}\n\n/**\n * Detect browser extensions (Chrome and Firefox at least).\n */\ninterface BrowserRuntime {\n  id?: unknown;\n}\ndeclare const chrome: { runtime?: BrowserRuntime };\ndeclare const browser: { runtime?: BrowserRuntime };\nexport function isBrowserExtension(): boolean {\n  const runtime =\n    typeof chrome === 'object'\n      ? chrome.runtime\n      : typeof browser === 'object'\n      ? browser.runtime\n      : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n\n/**\n * Detect React Native.\n *\n * @return true if ReactNative environment is detected.\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator === 'object' && navigator['product'] === 'ReactNative'\n  );\n}\n\n/** Detects Electron apps. */\nexport function isElectron(): boolean {\n  return getUA().indexOf('Electron/') >= 0;\n}\n\n/** Detects Internet Explorer. */\nexport function isIE(): boolean {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n\n/** Detects Universal Windows Platform apps. */\nexport function isUWP(): boolean {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n\n/**\n * Detect whether the current SDK build is the Node version.\n *\n * @return true if it's the Node SDK build.\n */\nexport function isNodeSdk(): boolean {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n\n/** Returns true if we are running in Safari. */\nexport function isSafari(): boolean {\n  return (\n    !isNode() &&\n    navigator.userAgent.includes('Safari') &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nexport function isIndexedDBAvailable(): boolean {\n  return 'indexedDB' in self && indexedDB != null;\n}\n\n/**\n * This method validates browser context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\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 = window.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          window.indexedDB.deleteDatabase(DB_CHECK_NAME);\n        }\n        resolve(true);\n      };\n      request.onupgradeneeded = () => {\n        preExist = false;\n      };\n\n      request.onerror = () => {\n        reject(request.error?.message || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n\n/**\n *\n * This method checks whether cookie is enabled within current browser\n * @return true if cookie is enabled within current browser\n */\nexport function areCookiesEnabled(): boolean {\n  if (!navigator || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n","/**\n * @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  INVALID_APP_ARGUMENT = 'invalid-app-argument',\n  INVALID_LOG_ARGUMENT = 'invalid-log-argument'\n}\n\nconst ERRORS: ErrorMap<AppError> = {\n  [AppError.NO_APP]:\n    \"No Firebase App '{$appName}' has been created - \" +\n    'call Firebase App.initializeApp()',\n  [AppError.BAD_APP_NAME]: \"Illegal App name: '{$appName}\",\n  [AppError.DUPLICATE_APP]: \"Firebase App named '{$appName}' already exists\",\n  [AppError.APP_DELETED]: \"Firebase App named '{$appName}' already deleted\",\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};\n\ntype ErrorParams = { [key in AppError]: { appName: string } };\n\nexport const ERROR_FACTORY = new ErrorFactory<AppError, ErrorParams>(\n  'app',\n  'Firebase',\n  ERRORS\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 * @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 sychronously 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 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","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (null != _i) {\n    var _s,\n      _e,\n      _x,\n      _r,\n      _arr = [],\n      _n = !0,\n      _d = !1;\n    try {\n      if (_x = (_i = _i.call(arr)).next, 0 === i) {\n        if (Object(_i) !== _i) return;\n        _n = !1;\n      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);\n    } catch (err) {\n      _d = !0, _e = err;\n    } finally {\n      try {\n        if (!_n && null != _i[\"return\"] && (_r = _i[\"return\"](), Object(_r) !== _r)) return;\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n    return _arr;\n  }\n}","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum ErrorCode {\n  MISSING_APP_CONFIG_VALUES = 'missing-app-config-values',\n  AVAILABLE_IN_WINDOW = 'only-available-in-window',\n  AVAILABLE_IN_SW = 'only-available-in-sw',\n  PERMISSION_DEFAULT = 'permission-default',\n  PERMISSION_BLOCKED = 'permission-blocked',\n  UNSUPPORTED_BROWSER = 'unsupported-browser',\n  FAILED_DEFAULT_REGISTRATION = 'failed-service-worker-registration',\n  TOKEN_SUBSCRIBE_FAILED = 'token-subscribe-failed',\n  TOKEN_SUBSCRIBE_NO_TOKEN = 'token-subscribe-no-token',\n  TOKEN_UNSUBSCRIBE_FAILED = 'token-unsubscribe-failed',\n  TOKEN_UPDATE_FAILED = 'token-update-failed',\n  TOKEN_UPDATE_NO_TOKEN = 'token-update-no-token',\n  INVALID_BG_HANDLER = 'invalid-bg-handler',\n  USE_SW_AFTER_GET_TOKEN = 'use-sw-after-get-token',\n  INVALID_SW_REGISTRATION = 'invalid-sw-registration',\n  USE_VAPID_KEY_AFTER_GET_TOKEN = 'use-vapid-key-after-get-token',\n  INVALID_VAPID_KEY = 'invalid-vapid-key'\n}\n\nexport const ERROR_MAP: ErrorMap<ErrorCode> = {\n  [ErrorCode.MISSING_APP_CONFIG_VALUES]:\n    'Missing App configuration value: \"{$valueName}\"',\n  [ErrorCode.AVAILABLE_IN_WINDOW]:\n    'This method is available in a Window context.',\n  [ErrorCode.AVAILABLE_IN_SW]:\n    'This method is available in a service worker context.',\n  [ErrorCode.PERMISSION_DEFAULT]:\n    'The notification permission was not granted and dismissed instead.',\n  [ErrorCode.PERMISSION_BLOCKED]:\n    'The notification permission was not granted and blocked instead.',\n  [ErrorCode.UNSUPPORTED_BROWSER]:\n    \"This browser doesn't support the API's required to use the firebase SDK.\",\n  [ErrorCode.FAILED_DEFAULT_REGISTRATION]:\n    'We are unable to register the default service worker. {$browserErrorMessage}',\n  [ErrorCode.TOKEN_SUBSCRIBE_FAILED]:\n    'A problem occurred while subscribing the user to FCM: {$errorInfo}',\n  [ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN]:\n    'FCM returned no token when subscribing the user to push.',\n  [ErrorCode.TOKEN_UNSUBSCRIBE_FAILED]:\n    'A problem occurred while unsubscribing the ' +\n    'user from FCM: {$errorInfo}',\n  [ErrorCode.TOKEN_UPDATE_FAILED]:\n    'A problem occurred while updating the user from FCM: {$errorInfo}',\n  [ErrorCode.TOKEN_UPDATE_NO_TOKEN]:\n    'FCM returned no token when updating the user to push.',\n  [ErrorCode.USE_SW_AFTER_GET_TOKEN]:\n    'The useServiceWorker() method may only be called once and must be ' +\n    'called before calling getToken() to ensure your service worker is used.',\n  [ErrorCode.INVALID_SW_REGISTRATION]:\n    'The input to useServiceWorker() must be a ServiceWorkerRegistration.',\n  [ErrorCode.INVALID_BG_HANDLER]:\n    'The input to setBackgroundMessageHandler() must be a function.',\n  [ErrorCode.INVALID_VAPID_KEY]: 'The public VAPID key must be a string.',\n  [ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN]:\n    'The usePublicVapidKey() method may only be called once and must be ' +\n    'called before calling getToken() to ensure your VAPID key is used.'\n};\n\ninterface ErrorParams {\n  [ErrorCode.MISSING_APP_CONFIG_VALUES]: {\n    valueName: string;\n  };\n  [ErrorCode.FAILED_DEFAULT_REGISTRATION]: { browserErrorMessage: string };\n  [ErrorCode.TOKEN_SUBSCRIBE_FAILED]: { errorInfo: string };\n  [ErrorCode.TOKEN_UNSUBSCRIBE_FAILED]: { errorInfo: string };\n  [ErrorCode.TOKEN_UPDATE_FAILED]: { errorInfo: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<ErrorCode, ErrorParams>(\n  'messaging',\n  'Messaging',\n  ERROR_MAP\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_SW_PATH = '/firebase-messaging-sw.js';\nexport const DEFAULT_SW_SCOPE = '/firebase-cloud-messaging-push-scope';\n\nexport const DEFAULT_VAPID_KEY =\n  'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4';\n\nexport const ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';\n\n// Key of FCM Payload in Notification's data field.\nexport const FCM_MSG = 'FCM_MSG';\nexport const TAG = 'FirebaseMessaging: ';\n\n// Set to '1' if Analytics is enabled for the campaign\nexport const CONSOLE_CAMPAIGN_ANALYTICS_ENABLED = 'google.c.a.e';\nexport const CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';\nexport const CONSOLE_CAMPAIGN_TIME = 'google.c.a.ts';\nexport const CONSOLE_CAMPAIGN_NAME = 'google.c.a.c_l';\n\n// Due to the fact that onBackgroundMessage can't be awaited (to support rxjs), a silent push\n// warning might be shown by the browser if the callback fails to completes by the end of onPush.\n// Experiments were ran to determine the majority onBackground message clock time. This brief\n// blocking time would allow majority of the onBackgroundMessage callback to finish.\nexport const BACKGROUND_HANDLE_EXECUTION_TIME_LIMIT_MS = 1000;\n\n// Preparation time for client to initialize and set up the message handler.\nexport const FOREGROUND_HANDLE_PREPARATION_TIME_MS = 3000;\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 { GenerateAuthTokenResponse } from '../interfaces/api-response';\nimport { AppConfig } from '../interfaces/app-config';\nimport {\n  CompletedAuthToken,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport {\n  INSTALLATIONS_API_URL,\n  INTERNAL_AUTH_VERSION\n} from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\n\nexport function getInstallationsEndpoint({ projectId }: AppConfig): string {\n  return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;\n}\n\nexport function extractAuthTokenInfoFromResponse(\n  response: GenerateAuthTokenResponse\n): CompletedAuthToken {\n  return {\n    token: response.token,\n    requestStatus: RequestStatus.COMPLETED,\n    expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),\n    creationTime: Date.now()\n  };\n}\n\nexport async function getErrorFromResponse(\n  requestName: string,\n  response: Response\n): Promise<FirebaseError> {\n  const responseJson: ErrorResponse = await response.json();\n  const errorData = responseJson.error;\n  return ERROR_FACTORY.create(ErrorCode.REQUEST_FAILED, {\n    requestName,\n    serverCode: errorData.code,\n    serverMessage: errorData.message,\n    serverStatus: errorData.status\n  });\n}\n\nexport function getHeaders({ apiKey }: AppConfig): Headers {\n  return new Headers({\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n    'x-goog-api-key': apiKey\n  });\n}\n\nexport function getHeadersWithAuth(\n  appConfig: AppConfig,\n  { refreshToken }: RegisteredInstallationEntry\n): Headers {\n  const headers = getHeaders(appConfig);\n  headers.append('Authorization', getAuthorizationHeader(refreshToken));\n  return headers;\n}\n\nexport interface ErrorResponse {\n  error: {\n    code: number;\n    message: string;\n    status: string;\n  };\n}\n\n/**\n * Calls the passed in fetch wrapper and returns the response.\n * If the returned response has a status of 5xx, re-runs the function once and\n * returns the response.\n */\nexport async function retryIfServerError(\n  fn: () => Promise<Response>\n): Promise<Response> {\n  const result = await fn();\n\n  if (result.status >= 500 && result.status < 600) {\n    // Internal Server Error. Retry request.\n    return fn();\n  }\n\n  return result;\n}\n\nfunction getExpiresInFromResponseExpiresIn(responseExpiresIn: string): number {\n  // This works because the server will never respond with fractions of a second.\n  return Number(responseExpiresIn.replace('s', '000'));\n}\n\nfunction getAuthorizationHeader(refreshToken: string): string {\n  return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;\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 { CreateInstallationResponse } from '../interfaces/api-response';\nimport { AppConfig } from '../interfaces/app-config';\nimport {\n  InProgressInstallationEntry,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport { INTERNAL_AUTH_VERSION, PACKAGE_VERSION } from '../util/constants';\nimport {\n  extractAuthTokenInfoFromResponse,\n  getErrorFromResponse,\n  getHeaders,\n  getInstallationsEndpoint,\n  retryIfServerError\n} from './common';\n\nexport async function createInstallationRequest(\n  appConfig: AppConfig,\n  { fid }: InProgressInstallationEntry\n): Promise<RegisteredInstallationEntry> {\n  const endpoint = getInstallationsEndpoint(appConfig);\n\n  const headers = getHeaders(appConfig);\n  const body = {\n    fid,\n    authVersion: INTERNAL_AUTH_VERSION,\n    appId: appConfig.appId,\n    sdkVersion: PACKAGE_VERSION\n  };\n\n  const request: RequestInit = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (response.ok) {\n    const responseValue: CreateInstallationResponse = await response.json();\n    const registeredInstallationEntry: RegisteredInstallationEntry = {\n      fid: responseValue.fid || fid,\n      registrationStatus: RequestStatus.COMPLETED,\n      refreshToken: responseValue.refreshToken,\n      authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)\n    };\n    return registeredInstallationEntry;\n  } else {\n    throw await getErrorFromResponse('Create Installation', response);\n  }\n}\n","/**\n * @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/** Returns a promise that resolves after given time passes. */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise<void>(resolve => {\n    setTimeout(resolve, ms);\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 function bufferToBase64UrlSafe(array: Uint8Array): string {\n  const b64 = btoa(String.fromCharCode(...array));\n  return b64.replace(/\\+/g, '-').replace(/\\//g, '_');\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 { bufferToBase64UrlSafe } from './buffer-to-base64-url-safe';\n\nexport const VALID_FID_PATTERN = /^[cdef][\\w-]{21}$/;\nexport const INVALID_FID = '';\n\n/**\n * Generates a new FID using random values from Web Crypto API.\n * Returns an empty string if FID generation fails for any reason.\n */\nexport function generateFid(): string {\n  try {\n    // A valid FID has exactly 22 base64 characters, which is 132 bits, or 16.5\n    // bytes. our implementation generates a 17 byte array instead.\n    const fidByteArray = new Uint8Array(17);\n    const crypto =\n      self.crypto || ((self as unknown) as { msCrypto: Crypto }).msCrypto;\n    crypto.getRandomValues(fidByteArray);\n\n    // Replace the first 4 random bits with the constant FID header of 0b0111.\n    fidByteArray[0] = 0b01110000 + (fidByteArray[0] % 0b00010000);\n\n    const fid = encode(fidByteArray);\n\n    return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;\n  } catch {\n    // FID generation errored\n    return INVALID_FID;\n  }\n}\n\n/** Converts a FID Uint8Array to a base64 string representation. */\nfunction encode(fidByteArray: Uint8Array): string {\n  const b64String = bufferToBase64UrlSafe(fidByteArray);\n\n  // Remove the 23rd character that was added because of the extra 4 bits at the\n  // end of our 17 byte array, and the '=' padding.\n  return b64String.substr(0, 22);\n}\n","/**\n * @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 { AppConfig } from '../interfaces/app-config';\n\n/** Returns a string key that can be used to identify the app. */\nexport function getKey(appConfig: AppConfig): string {\n  return `${appConfig.appName}!${appConfig.appId}`;\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 { getKey } from '../util/get-key';\nimport { AppConfig } from '../interfaces/app-config';\nimport { IdChangeCallbackFn } from '../functions';\n\nconst fidChangeCallbacks: Map<string, Set<IdChangeCallbackFn>> = new Map();\n\n/**\n * Calls the onIdChange callbacks with the new FID value, and broadcasts the\n * change to other tabs.\n */\nexport function fidChanged(appConfig: AppConfig, fid: string): void {\n  const key = getKey(appConfig);\n\n  callFidChangeCallbacks(key, fid);\n  broadcastFidChange(key, fid);\n}\n\nexport function addCallback(\n  appConfig: AppConfig,\n  callback: IdChangeCallbackFn\n): void {\n  // Open the broadcast channel if it's not already open,\n  // to be able to listen to change events from other tabs.\n  getBroadcastChannel();\n\n  const key = getKey(appConfig);\n\n  let callbackSet = fidChangeCallbacks.get(key);\n  if (!callbackSet) {\n    callbackSet = new Set();\n    fidChangeCallbacks.set(key, callbackSet);\n  }\n  callbackSet.add(callback);\n}\n\nexport function removeCallback(\n  appConfig: AppConfig,\n  callback: IdChangeCallbackFn\n): void {\n  const key = getKey(appConfig);\n\n  const callbackSet = fidChangeCallbacks.get(key);\n\n  if (!callbackSet) {\n    return;\n  }\n\n  callbackSet.delete(callback);\n  if (callbackSet.size === 0) {\n    fidChangeCallbacks.delete(key);\n  }\n\n  // Close broadcast channel if there are no more callbacks.\n  closeBroadcastChannel();\n}\n\nfunction callFidChangeCallbacks(key: string, fid: string): void {\n  const callbacks = fidChangeCallbacks.get(key);\n  if (!callbacks) {\n    return;\n  }\n\n  for (const callback of callbacks) {\n    callback(fid);\n  }\n}\n\nfunction broadcastFidChange(key: string, fid: string): void {\n  const channel = getBroadcastChannel();\n  if (channel) {\n    channel.postMessage({ key, fid });\n  }\n  closeBroadcastChannel();\n}\n\nlet broadcastChannel: BroadcastChannel | null = null;\n/** Opens and returns a BroadcastChannel if it is supported by the browser. */\nfunction getBroadcastChannel(): BroadcastChannel | null {\n  if (!broadcastChannel && 'BroadcastChannel' in self) {\n    broadcastChannel = new BroadcastChannel('[Firebase] FID Change');\n    broadcastChannel.onmessage = e => {\n      callFidChangeCallbacks(e.data.key, e.data.fid);\n    };\n  }\n  return broadcastChannel;\n}\n\nfunction closeBroadcastChannel(): void {\n  if (fidChangeCallbacks.size === 0 && broadcastChannel) {\n    broadcastChannel.close();\n    broadcastChannel = null;\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 { DB, deleteDb, openDb } from 'idb';\n\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\nimport { TokenDetails } from '../interfaces/token-details';\nimport { migrateOldDatabase } from './migrate-old-database';\n\n// Exported for tests.\nexport const DATABASE_NAME = 'firebase-messaging-database';\nconst DATABASE_VERSION = 1;\nconst OBJECT_STORE_NAME = 'firebase-messaging-store';\n\nlet dbPromise: Promise<DB> | null = null;\nfunction getDbPromise(): Promise<DB> {\n  if (!dbPromise) {\n    dbPromise = openDb(DATABASE_NAME, DATABASE_VERSION, upgradeDb => {\n      // We don't use 'break' in this switch statement, the fall-through behavior is what we want,\n      // because if there are multiple versions between the old version and the current version, we\n      // want ALL the migrations that correspond to those versions to run, not only the last one.\n      // eslint-disable-next-line default-case\n      switch (upgradeDb.oldVersion) {\n        case 0:\n          upgradeDb.createObjectStore(OBJECT_STORE_NAME);\n      }\n    });\n  }\n  return dbPromise;\n}\n\n/** Gets record(s) from the objectStore that match the given key. */\nexport async function dbGet(\n  firebaseDependencies: FirebaseInternalDependencies\n): Promise<TokenDetails | undefined> {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tokenDetails = await db\n    .transaction(OBJECT_STORE_NAME)\n    .objectStore(OBJECT_STORE_NAME)\n    .get(key);\n\n  if (tokenDetails) {\n    return tokenDetails;\n  } else {\n    // Check if there is a tokenDetails object in the old DB.\n    const oldTokenDetails = await migrateOldDatabase(\n      firebaseDependencies.appConfig.senderId\n    );\n    if (oldTokenDetails) {\n      await dbSet(firebaseDependencies, oldTokenDetails);\n      return oldTokenDetails;\n    }\n  }\n}\n\n/** Assigns or overwrites the record for the given key with the given value. */\nexport async function dbSet(\n  firebaseDependencies: FirebaseInternalDependencies,\n  tokenDetails: TokenDetails\n): Promise<TokenDetails> {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key);\n  await tx.complete;\n  return tokenDetails;\n}\n\n/** Removes record(s) from the objectStore that match the given key. */\nexport async function dbRemove(\n  firebaseDependencies: FirebaseInternalDependencies\n): Promise<void> {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).delete(key);\n  await tx.complete;\n}\n\n/** Deletes the DB. Useful for tests. */\nexport async function dbDelete(): Promise<void> {\n  if (dbPromise) {\n    (await dbPromise).close();\n    await deleteDb(DATABASE_NAME);\n    dbPromise = null;\n  }\n}\n\nfunction getKey({ appConfig }: FirebaseInternalDependencies): string {\n  return appConfig.appId;\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 '@firebase/installations';\n\nimport {\n  Component,\n  ComponentContainer,\n  ComponentType\n} from '@firebase/component';\nimport { ERROR_FACTORY, ErrorCode } from './util/errors';\nimport {\n  FirebaseService,\n  _FirebaseNamespace\n} from '@firebase/app-types/private';\n\nimport { FirebaseInternalDependencies } from './interfaces/internal-dependencies';\nimport { FirebaseMessaging } from '@firebase/messaging-types';\nimport { SwController } from './controllers/sw-controller';\nimport { WindowController } from './controllers/window-controller';\nimport { extractAppConfig } from './helpers/extract-app-config';\nimport firebase from '@firebase/app';\n\nconst MESSAGING_NAME = 'messaging';\nfunction factoryMethod(\n  container: ComponentContainer\n): FirebaseService & FirebaseMessaging {\n  // Dependencies.\n  const app = container.getProvider('app').getImmediate();\n  const appConfig = extractAppConfig(app);\n  const installations = container.getProvider('installations').getImmediate();\n  const analyticsProvider = container.getProvider('analytics-internal');\n\n  const firebaseDependencies: FirebaseInternalDependencies = {\n    app,\n    appConfig,\n    installations,\n    analyticsProvider\n  };\n\n  if (!isSupported()) {\n    throw ERROR_FACTORY.create(ErrorCode.UNSUPPORTED_BROWSER);\n  }\n\n  if (self && 'ServiceWorkerGlobalScope' in self) {\n    // Running in ServiceWorker context\n    return new SwController(firebaseDependencies);\n  } else {\n    // Assume we are in the window context.\n    return new WindowController(firebaseDependencies);\n  }\n}\n\nconst NAMESPACE_EXPORTS = {\n  isSupported\n};\n\n(firebase as _FirebaseNamespace).INTERNAL.registerComponent(\n  new Component(\n    MESSAGING_NAME,\n    factoryMethod,\n    ComponentType.PUBLIC\n  ).setServiceProps(NAMESPACE_EXPORTS)\n);\n\n/**\n * Define extension behavior of `registerMessaging`\n */\ndeclare module '@firebase/app-types' {\n  interface FirebaseNamespace {\n    messaging: {\n      (app?: FirebaseApp): FirebaseMessaging;\n      isSupported(): boolean;\n    };\n  }\n  interface FirebaseApp {\n    messaging(): FirebaseMessaging;\n  }\n}\n\nfunction isSupported(): boolean {\n  if (self && 'ServiceWorkerGlobalScope' in self) {\n    // Running in ServiceWorker context\n    return isSWControllerSupported();\n  } else {\n    // Assume we are in the window context.\n    return isWindowControllerSupported();\n  }\n}\n\n/**\n * Checks to see if the required APIs exist.\n */\nfunction isWindowControllerSupported(): boolean {\n  return (\n    'indexedDB' in window &&\n    indexedDB !== null &&\n    navigator.cookieEnabled &&\n    'serviceWorker' in navigator &&\n    'PushManager' in window &&\n    'Notification' in window &&\n    'fetch' in window &&\n    ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&\n    PushSubscription.prototype.hasOwnProperty('getKey')\n  );\n}\n\n/**\n * Checks to see if the required APIs exist within SW Context.\n */\nfunction isSWControllerSupported(): boolean {\n  return (\n    'indexedDB' in self &&\n    indexedDB !== null &&\n    'PushManager' in self &&\n    'Notification' in self &&\n    ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&\n    PushSubscription.prototype.hasOwnProperty('getKey')\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 { createInstallationRequest } from '../api/create-installation-request';\nimport { AppConfig } from '../interfaces/app-config';\nimport {\n  InProgressInstallationEntry,\n  InstallationEntry,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport { PENDING_TIMEOUT_MS } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode, isServerError } from '../util/errors';\nimport { sleep } from '../util/sleep';\nimport { generateFid, INVALID_FID } from './generate-fid';\nimport { remove, set, update } from './idb-manager';\n\nexport interface InstallationEntryWithRegistrationPromise {\n  installationEntry: InstallationEntry;\n  /** Exist iff the installationEntry is not registered. */\n  registrationPromise?: Promise<RegisteredInstallationEntry>;\n}\n\n/**\n * Updates and returns the InstallationEntry from the database.\n * Also triggers a registration request if it is necessary and possible.\n */\nexport async function getInstallationEntry(\n  appConfig: AppConfig\n): Promise<InstallationEntryWithRegistrationPromise> {\n  let registrationPromise: Promise<RegisteredInstallationEntry> | undefined;\n\n  const installationEntry = await update(appConfig, oldEntry => {\n    const installationEntry = updateOrCreateInstallationEntry(oldEntry);\n    const entryWithPromise = triggerRegistrationIfNecessary(\n      appConfig,\n      installationEntry\n    );\n    registrationPromise = entryWithPromise.registrationPromise;\n    return entryWithPromise.installationEntry;\n  });\n\n  if (installationEntry.fid === INVALID_FID) {\n    // FID generation failed. Waiting for the FID from the server.\n    return { installationEntry: await registrationPromise! };\n  }\n\n  return {\n    installationEntry,\n    registrationPromise\n  };\n}\n\n/**\n * Creates a new Installation Entry if one does not exist.\n * Also clears timed out pending requests.\n */\nfunction updateOrCreateInstallationEntry(\n  oldEntry: InstallationEntry | undefined\n): InstallationEntry {\n  const entry: InstallationEntry = oldEntry || {\n    fid: generateFid(),\n    registrationStatus: RequestStatus.NOT_STARTED\n  };\n\n  return clearTimedOutRequest(entry);\n}\n\n/**\n * If the Firebase Installation is not registered yet, this will trigger the\n * registration and return an InProgressInstallationEntry.\n *\n * If registrationPromise does not exist, the installationEntry is guaranteed\n * to be registered.\n */\nfunction triggerRegistrationIfNecessary(\n  appConfig: AppConfig,\n  installationEntry: InstallationEntry\n): InstallationEntryWithRegistrationPromise {\n  if (installationEntry.registrationStatus === RequestStatus.NOT_STARTED) {\n    if (!navigator.onLine) {\n      // Registration required but app is offline.\n      const registrationPromiseWithError = Promise.reject(\n        ERROR_FACTORY.create(ErrorCode.APP_OFFLINE)\n      );\n      return {\n        installationEntry,\n        registrationPromise: registrationPromiseWithError\n      };\n    }\n\n    // Try registering. Change status to IN_PROGRESS.\n    const inProgressEntry: InProgressInstallationEntry = {\n      fid: installationEntry.fid,\n      registrationStatus: RequestStatus.IN_PROGRESS,\n      registrationTime: Date.now()\n    };\n    const registrationPromise = registerInstallation(\n      appConfig,\n      inProgressEntry\n    );\n    return { installationEntry: inProgressEntry, registrationPromise };\n  } else if (\n    installationEntry.registrationStatus === RequestStatus.IN_PROGRESS\n  ) {\n    return {\n      installationEntry,\n      registrationPromise: waitUntilFidRegistration(appConfig)\n    };\n  } else {\n    return { installationEntry };\n  }\n}\n\n/** This will be executed only once for each new Firebase Installation. */\nasync function registerInstallation(\n  appConfig: AppConfig,\n  installationEntry: InProgressInstallationEntry\n): Promise<RegisteredInstallationEntry> {\n  try {\n    const registeredInstallationEntry = await createInstallationRequest(\n      appConfig,\n      installationEntry\n    );\n    return set(appConfig, registeredInstallationEntry);\n  } catch (e) {\n    if (isServerError(e) && e.customData.serverCode === 409) {\n      // Server returned a \"FID can not be used\" error.\n      // Generate a new ID next time.\n      await remove(appConfig);\n    } else {\n      // Registration failed. Set FID as not registered.\n      await set(appConfig, {\n        fid: installationEntry.fid,\n        registrationStatus: RequestStatus.NOT_STARTED\n      });\n    }\n    throw e;\n  }\n}\n\n/** Call if FID registration is pending in another request. */\nasync function waitUntilFidRegistration(\n  appConfig: AppConfig\n): Promise<RegisteredInstallationEntry> {\n  // Unfortunately, there is no way of reliably observing when a value in\n  // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers),\n  // so we need to poll.\n\n  let entry: InstallationEntry = await updateInstallationRequest(appConfig);\n  while (entry.registrationStatus === RequestStatus.IN_PROGRESS) {\n    // createInstallation request still in progress.\n    await sleep(100);\n\n    entry = await updateInstallationRequest(appConfig);\n  }\n\n  if (entry.registrationStatus === RequestStatus.NOT_STARTED) {\n    // The request timed out or failed in a different call. Try again.\n    const {\n      installationEntry,\n      registrationPromise\n    } = await getInstallationEntry(appConfig);\n\n    if (registrationPromise) {\n      return registrationPromise;\n    } else {\n      // if there is no registrationPromise, entry is registered.\n      return installationEntry as RegisteredInstallationEntry;\n    }\n  }\n\n  return entry;\n}\n\n/**\n * Called only if there is a CreateInstallation request in progress.\n *\n * Updates the InstallationEntry in the DB based on the status of the\n * CreateInstallation request.\n *\n * Returns the updated InstallationEntry.\n */\nfunction updateInstallationRequest(\n  appConfig: AppConfig\n): Promise<InstallationEntry> {\n  return update(appConfig, oldEntry => {\n    if (!oldEntry) {\n      throw ERROR_FACTORY.create(ErrorCode.INSTALLATION_NOT_FOUND);\n    }\n    return clearTimedOutRequest(oldEntry);\n  });\n}\n\nfunction clearTimedOutRequest(entry: InstallationEntry): InstallationEntry {\n  if (hasInstallationRequestTimedOut(entry)) {\n    return {\n      fid: entry.fid,\n      registrationStatus: RequestStatus.NOT_STARTED\n    };\n  }\n\n  return entry;\n}\n\nfunction hasInstallationRequestTimedOut(\n  installationEntry: InstallationEntry\n): boolean {\n  return (\n    installationEntry.registrationStatus === RequestStatus.IN_PROGRESS &&\n    installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now()\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 { GenerateAuthTokenResponse } from '../interfaces/api-response';\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseDependencies } from '../interfaces/firebase-dependencies';\nimport {\n  CompletedAuthToken,\n  RegisteredInstallationEntry\n} from '../interfaces/installation-entry';\nimport { PACKAGE_VERSION } from '../util/constants';\nimport {\n  extractAuthTokenInfoFromResponse,\n  getErrorFromResponse,\n  getHeadersWithAuth,\n  getInstallationsEndpoint,\n  retryIfServerError\n} from './common';\n\nexport async function generateAuthTokenRequest(\n  { appConfig, platformLoggerProvider }: FirebaseDependencies,\n  installationEntry: RegisteredInstallationEntry\n): Promise<CompletedAuthToken> {\n  const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry);\n\n  const headers = getHeadersWithAuth(appConfig, installationEntry);\n\n  // If platform logger exists, add the platform info string to the header.\n  const platformLogger = platformLoggerProvider.getImmediate({\n    optional: true\n  });\n  if (platformLogger) {\n    headers.append('x-firebase-client', platformLogger.getPlatformInfoString());\n  }\n\n  const body = {\n    installation: {\n      sdkVersion: PACKAGE_VERSION\n    }\n  };\n\n  const request: RequestInit = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (response.ok) {\n    const responseValue: GenerateAuthTokenResponse = await response.json();\n    const completedAuthToken: CompletedAuthToken = extractAuthTokenInfoFromResponse(\n      responseValue\n    );\n    return completedAuthToken;\n  } else {\n    throw await getErrorFromResponse('Generate Auth Token', response);\n  }\n}\n\nfunction getGenerateAuthTokenEndpoint(\n  appConfig: AppConfig,\n  { fid }: RegisteredInstallationEntry\n): string {\n  return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`;\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 { generateAuthTokenRequest } from '../api/generate-auth-token-request';\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseDependencies } from '../interfaces/firebase-dependencies';\nimport {\n  AuthToken,\n  CompletedAuthToken,\n  InProgressAuthToken,\n  InstallationEntry,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport { PENDING_TIMEOUT_MS, TOKEN_EXPIRATION_BUFFER } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode, isServerError } from '../util/errors';\nimport { sleep } from '../util/sleep';\nimport { remove, set, update } from './idb-manager';\n\n/**\n * Returns a valid authentication token for the installation. Generates a new\n * token if one doesn't exist, is expired or about to expire.\n *\n * Should only be called if the Firebase Installation is registered.\n */\nexport async function refreshAuthToken(\n  dependencies: FirebaseDependencies,\n  forceRefresh = false\n): Promise<CompletedAuthToken> {\n  let tokenPromise: Promise<CompletedAuthToken> | undefined;\n  const entry = await update(dependencies.appConfig, oldEntry => {\n    if (!isEntryRegistered(oldEntry)) {\n      throw ERROR_FACTORY.create(ErrorCode.NOT_REGISTERED);\n    }\n\n    const oldAuthToken = oldEntry.authToken;\n    if (!forceRefresh && isAuthTokenValid(oldAuthToken)) {\n      // There is a valid token in the DB.\n      return oldEntry;\n    } else if (oldAuthToken.requestStatus === RequestStatus.IN_PROGRESS) {\n      // There already is a token request in progress.\n      tokenPromise = waitUntilAuthTokenRequest(dependencies, forceRefresh);\n      return oldEntry;\n    } else {\n      // No token or token expired.\n      if (!navigator.onLine) {\n        throw ERROR_FACTORY.create(ErrorCode.APP_OFFLINE);\n      }\n\n      const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry);\n      tokenPromise = fetchAuthTokenFromServer(dependencies, inProgressEntry);\n      return inProgressEntry;\n    }\n  });\n\n  const authToken = tokenPromise\n    ? await tokenPromise\n    : (entry.authToken as CompletedAuthToken);\n  return authToken;\n}\n\n/**\n * Call only if FID is registered and Auth Token request is in progress.\n *\n * Waits until the current pending request finishes. If the request times out,\n * tries once in this thread as well.\n */\nasync function waitUntilAuthTokenRequest(\n  dependencies: FirebaseDependencies,\n  forceRefresh: boolean\n): Promise<CompletedAuthToken> {\n  // Unfortunately, there is no way of reliably observing when a value in\n  // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers),\n  // so we need to poll.\n\n  let entry = await updateAuthTokenRequest(dependencies.appConfig);\n  while (entry.authToken.requestStatus === RequestStatus.IN_PROGRESS) {\n    // generateAuthToken still in progress.\n    await sleep(100);\n\n    entry = await updateAuthTokenRequest(dependencies.appConfig);\n  }\n\n  const authToken = entry.authToken;\n  if (authToken.requestStatus === RequestStatus.NOT_STARTED) {\n    // The request timed out or failed in a different call. Try again.\n    return refreshAuthToken(dependencies, forceRefresh);\n  } else {\n    return authToken;\n  }\n}\n\n/**\n * Called only if there is a GenerateAuthToken request in progress.\n *\n * Updates the InstallationEntry in the DB based on the status of the\n * GenerateAuthToken request.\n *\n * Returns the updated InstallationEntry.\n */\nfunction updateAuthTokenRequest(\n  appConfig: AppConfig\n): Promise<RegisteredInstallationEntry> {\n  return update(appConfig, oldEntry => {\n    if (!isEntryRegistered(oldEntry)) {\n      throw ERROR_FACTORY.create(ErrorCode.NOT_REGISTERED);\n    }\n\n    const oldAuthToken = oldEntry.authToken;\n    if (hasAuthTokenRequestTimedOut(oldAuthToken)) {\n      return {\n        ...oldEntry,\n        authToken: { requestStatus: RequestStatus.NOT_STARTED }\n      };\n    }\n\n    return oldEntry;\n  });\n}\n\nasync function fetchAuthTokenFromServer(\n  dependencies: FirebaseDependencies,\n  installationEntry: RegisteredInstallationEntry\n): Promise<CompletedAuthToken> {\n  try {\n    const authToken = await generateAuthTokenRequest(\n      dependencies,\n      installationEntry\n    );\n    const updatedInstallationEntry: RegisteredInstallationEntry = {\n      ...installationEntry,\n      authToken\n    };\n    await set(dependencies.appConfig, updatedInstallationEntry);\n    return authToken;\n  } catch (e) {\n    if (\n      isServerError(e) &&\n      (e.customData.serverCode === 401 || e.customData.serverCode === 404)\n    ) {\n      // Server returned a \"FID not found\" or a \"Invalid authentication\" error.\n      // Generate a new ID next time.\n      await remove(dependencies.appConfig);\n    } else {\n      const updatedInstallationEntry: RegisteredInstallationEntry = {\n        ...installationEntry,\n        authToken: { requestStatus: RequestStatus.NOT_STARTED }\n      };\n      await set(dependencies.appConfig, updatedInstallationEntry);\n    }\n    throw e;\n  }\n}\n\nfunction isEntryRegistered(\n  installationEntry: InstallationEntry | undefined\n): installationEntry is RegisteredInstallationEntry {\n  return (\n    installationEntry !== undefined &&\n    installationEntry.registrationStatus === RequestStatus.COMPLETED\n  );\n}\n\nfunction isAuthTokenValid(authToken: AuthToken): boolean {\n  return (\n    authToken.requestStatus === RequestStatus.COMPLETED &&\n    !isAuthTokenExpired(authToken)\n  );\n}\n\nfunction isAuthTokenExpired(authToken: CompletedAuthToken): boolean {\n  const now = Date.now();\n  return (\n    now < authToken.creationTime ||\n    authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER\n  );\n}\n\n/** Returns an updated InstallationEntry with an InProgressAuthToken. */\nfunction makeAuthTokenRequestInProgressEntry(\n  oldEntry: RegisteredInstallationEntry\n): RegisteredInstallationEntry {\n  const inProgressAuthToken: InProgressAuthToken = {\n    requestStatus: RequestStatus.IN_PROGRESS,\n    requestTime: Date.now()\n  };\n  return {\n    ...oldEntry,\n    authToken: inProgressAuthToken\n  };\n}\n\nfunction hasAuthTokenRequestTimedOut(authToken: AuthToken): boolean {\n  return (\n    authToken.requestStatus === RequestStatus.IN_PROGRESS &&\n    authToken.requestTime + PENDING_TIMEOUT_MS < Date.now()\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 { getInstallationEntry } from '../helpers/get-installation-entry';\nimport { refreshAuthToken } from '../helpers/refresh-auth-token';\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseDependencies } from '../interfaces/firebase-dependencies';\n\nexport async function getToken(\n  dependencies: FirebaseDependencies,\n  forceRefresh = false\n): Promise<string> {\n  await completeInstallationRegistration(dependencies.appConfig);\n\n  // At this point we either have a Registered Installation in the DB, or we've\n  // already thrown an error.\n  const authToken = await refreshAuthToken(dependencies, forceRefresh);\n  return authToken.token;\n}\n\nasync function completeInstallationRegistration(\n  appConfig: AppConfig\n): Promise<void> {\n  const { registrationPromise } = await getInstallationEntry(appConfig);\n\n  if (registrationPromise) {\n    // A createInstallation request is in progress. Wait until it finishes.\n    await registrationPromise;\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 { AppConfig } from '../interfaces/app-config';\nimport { RegisteredInstallationEntry } from '../interfaces/installation-entry';\nimport {\n  getErrorFromResponse,\n  getHeadersWithAuth,\n  getInstallationsEndpoint,\n  retryIfServerError\n} from './common';\n\nexport async function deleteInstallationRequest(\n  appConfig: AppConfig,\n  installationEntry: RegisteredInstallationEntry\n): Promise<void> {\n  const endpoint = getDeleteEndpoint(appConfig, installationEntry);\n\n  const headers = getHeadersWithAuth(appConfig, installationEntry);\n  const request: RequestInit = {\n    method: 'DELETE',\n    headers\n  };\n\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (!response.ok) {\n    throw await getErrorFromResponse('Delete Installation', response);\n  }\n}\n\nfunction getDeleteEndpoint(\n  appConfig: AppConfig,\n  { fid }: RegisteredInstallationEntry\n): string {\n  return `${getInstallationsEndpoint(appConfig)}/${fid}`;\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 { addCallback, removeCallback } from '../helpers/fid-changed';\nimport { FirebaseDependencies } from '../interfaces/firebase-dependencies';\n\nexport type IdChangeCallbackFn = (installationId: string) => void;\nexport type IdChangeUnsubscribeFn = () => void;\n\n/**\n * Sets a new callback that will get called when Installation ID changes.\n * Returns an unsubscribe function that will remove the callback when called.\n */\nexport function onIdChange(\n  { appConfig }: FirebaseDependencies,\n  callback: IdChangeCallbackFn\n): IdChangeUnsubscribeFn {\n  addCallback(appConfig, callback);\n\n  return () => {\n    removeCallback(appConfig, callback);\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 { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { FirebaseApp, FirebaseOptions } from '@firebase/app-types';\n\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseError } from '@firebase/util';\n\nexport function extractAppConfig(app: FirebaseApp): AppConfig {\n  if (!app || !app.options) {\n    throw getMissingValueError('App Configuration Object');\n  }\n\n  if (!app.name) {\n    throw getMissingValueError('App Name');\n  }\n\n  // Required app config keys\n  const configKeys: ReadonlyArray<keyof FirebaseOptions> = [\n    'projectId',\n    'apiKey',\n    'appId',\n    'messagingSenderId'\n  ];\n\n  const { options } = app;\n  for (const keyName of configKeys) {\n    if (!options[keyName]) {\n      throw getMissingValueError(keyName);\n    }\n  }\n\n  return {\n    appName: app.name,\n    projectId: options.projectId!,\n    apiKey: options.apiKey!,\n    appId: options.appId!,\n    senderId: options.messagingSenderId!\n  };\n}\n\nfunction getMissingValueError(valueName: string): FirebaseError {\n  return ERROR_FACTORY.create(ErrorCode.MISSING_APP_CONFIG_VALUES, {\n    valueName\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 { getInstallationEntry } from '../helpers/get-installation-entry';\nimport { refreshAuthToken } from '../helpers/refresh-auth-token';\nimport { FirebaseDependencies } from '../interfaces/firebase-dependencies';\n\nexport async function getId(\n  dependencies: FirebaseDependencies\n): Promise<string> {\n  const { installationEntry, registrationPromise } = await getInstallationEntry(\n    dependencies.appConfig\n  );\n\n  if (registrationPromise) {\n    registrationPromise.catch(console.error);\n  } else {\n    // If the installation is already registered, update the authentication\n    // token if needed.\n    refreshAuthToken(dependencies).catch(console.error);\n  }\n\n  return installationEntry.fid;\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 { deleteInstallationRequest } from '../api/delete-installation-request';\nimport { remove, update } from '../helpers/idb-manager';\nimport { FirebaseDependencies } from '../interfaces/firebase-dependencies';\nimport { RequestStatus } from '../interfaces/installation-entry';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\n\nexport async function deleteInstallation(\n  dependencies: FirebaseDependencies\n): Promise<void> {\n  const { appConfig } = dependencies;\n\n  const entry = await update(appConfig, oldEntry => {\n    if (oldEntry && oldEntry.registrationStatus === RequestStatus.NOT_STARTED) {\n      // Delete the unregistered entry without sending a deleteInstallation request.\n      return undefined;\n    }\n    return oldEntry;\n  });\n\n  if (entry) {\n    if (entry.registrationStatus === RequestStatus.IN_PROGRESS) {\n      // Can't delete while trying to register.\n      throw ERROR_FACTORY.create(ErrorCode.DELETE_PENDING_REGISTRATION);\n    } else if (entry.registrationStatus === RequestStatus.COMPLETED) {\n      if (!navigator.onLine) {\n        throw ERROR_FACTORY.create(ErrorCode.APP_OFFLINE);\n      } else {\n        await deleteInstallationRequest(appConfig, entry);\n        await remove(appConfig);\n      }\n    }\n  }\n}\n","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import addDays from 'date-fns/addDays';\nimport addMonths from 'date-fns/addMonths';\nimport addYears from 'date-fns/addYears';\nimport differenceInMilliseconds from 'date-fns/differenceInMilliseconds';\nimport eachDayOfInterval from 'date-fns/eachDayOfInterval';\nimport endOfDay from 'date-fns/endOfDay';\nimport endOfWeek from 'date-fns/endOfWeek';\nimport endOfYear from 'date-fns/endOfYear';\nimport format from 'date-fns/format';\nimport getHours from 'date-fns/getHours';\nimport getSeconds from 'date-fns/getSeconds';\nimport getYear from 'date-fns/getYear';\nimport isAfter from 'date-fns/isAfter';\nimport isBefore from 'date-fns/isBefore';\nimport isEqual from 'date-fns/isEqual';\nimport isSameDay from 'date-fns/isSameDay';\nimport isSameYear from 'date-fns/isSameYear';\nimport isSameMonth from 'date-fns/isSameMonth';\nimport isSameHour from 'date-fns/isSameHour';\nimport isValid from 'date-fns/isValid';\nimport dateFnsParse from 'date-fns/parse';\nimport setHours from 'date-fns/setHours';\nimport setMinutes from 'date-fns/setMinutes';\nimport setMonth from 'date-fns/setMonth';\nimport setSeconds from 'date-fns/setSeconds';\nimport setYear from 'date-fns/setYear';\nimport startOfDay from 'date-fns/startOfDay';\nimport startOfMonth from 'date-fns/startOfMonth';\nimport endOfMonth from 'date-fns/endOfMonth';\nimport startOfWeek from 'date-fns/startOfWeek';\nimport startOfYear from 'date-fns/startOfYear';\n\nvar DateFnsUtils = /** @class */ (function () {\n    function DateFnsUtils(_a) {\n        var locale = (_a === void 0 ? {} : _a).locale;\n        this.yearFormat = \"yyyy\";\n        this.yearMonthFormat = \"MMMM yyyy\";\n        this.dateTime12hFormat = \"MMMM do hh:mm aaaa\";\n        this.dateTime24hFormat = \"MMMM do HH:mm\";\n        this.time12hFormat = \"hh:mm a\";\n        this.time24hFormat = \"HH:mm\";\n        this.dateFormat = \"MMMM do\";\n        this.locale = locale;\n    }\n    // Note: date-fns input types are more lenient than this adapter, so we need to expose our more\n    // strict signature and delegate to the more lenient signature. Otherwise, we have downstream type errors upon usage.\n    DateFnsUtils.prototype.addDays = function (value, count) {\n        return addDays(value, count);\n    };\n    DateFnsUtils.prototype.isValid = function (value) {\n        return isValid(this.date(value));\n    };\n    DateFnsUtils.prototype.getDiff = function (value, comparing) {\n        return differenceInMilliseconds(value, this.date(comparing));\n    };\n    DateFnsUtils.prototype.isAfter = function (value, comparing) {\n        return isAfter(value, comparing);\n    };\n    DateFnsUtils.prototype.isBefore = function (value, comparing) {\n        return isBefore(value, comparing);\n    };\n    DateFnsUtils.prototype.startOfDay = function (value) {\n        return startOfDay(value);\n    };\n    DateFnsUtils.prototype.endOfDay = function (value) {\n        return endOfDay(value);\n    };\n    DateFnsUtils.prototype.getHours = function (value) {\n        return getHours(value);\n    };\n    DateFnsUtils.prototype.setHours = function (value, count) {\n        return setHours(value, count);\n    };\n    DateFnsUtils.prototype.setMinutes = function (value, count) {\n        return setMinutes(value, count);\n    };\n    DateFnsUtils.prototype.getSeconds = function (value) {\n        return getSeconds(value);\n    };\n    DateFnsUtils.prototype.setSeconds = function (value, count) {\n        return setSeconds(value, count);\n    };\n    DateFnsUtils.prototype.isSameDay = function (value, comparing) {\n        return isSameDay(value, comparing);\n    };\n    DateFnsUtils.prototype.isSameMonth = function (value, comparing) {\n        return isSameMonth(value, comparing);\n    };\n    DateFnsUtils.prototype.isSameYear = function (value, comparing) {\n        return isSameYear(value, comparing);\n    };\n    DateFnsUtils.prototype.isSameHour = function (value, comparing) {\n        return isSameHour(value, comparing);\n    };\n    DateFnsUtils.prototype.startOfMonth = function (value) {\n        return startOfMonth(value);\n    };\n    DateFnsUtils.prototype.endOfMonth = function (value) {\n        return endOfMonth(value);\n    };\n    DateFnsUtils.prototype.getYear = function (value) {\n        return getYear(value);\n    };\n    DateFnsUtils.prototype.setYear = function (value, count) {\n        return setYear(value, count);\n    };\n    DateFnsUtils.prototype.date = function (value) {\n        if (typeof value === \"undefined\") {\n            return new Date();\n        }\n        if (value === null) {\n            return null;\n        }\n        return new Date(value);\n    };\n    DateFnsUtils.prototype.parse = function (value, formatString) {\n        if (value === \"\") {\n            return null;\n        }\n        return dateFnsParse(value, formatString, new Date(), { locale: this.locale });\n    };\n    DateFnsUtils.prototype.format = function (date, formatString) {\n        return format(date, formatString, { locale: this.locale });\n    };\n    DateFnsUtils.prototype.isEqual = function (date, comparing) {\n        if (date === null && comparing === null) {\n            return true;\n        }\n        return isEqual(date, comparing);\n    };\n    DateFnsUtils.prototype.isNull = function (date) {\n        return date === null;\n    };\n    DateFnsUtils.prototype.isAfterDay = function (date, value) {\n        return isAfter(date, endOfDay(value));\n    };\n    DateFnsUtils.prototype.isBeforeDay = function (date, value) {\n        return isBefore(date, startOfDay(value));\n    };\n    DateFnsUtils.prototype.isBeforeYear = function (date, value) {\n        return isBefore(date, startOfYear(value));\n    };\n    DateFnsUtils.prototype.isAfterYear = function (date, value) {\n        return isAfter(date, endOfYear(value));\n    };\n    DateFnsUtils.prototype.formatNumber = function (numberToFormat) {\n        return numberToFormat;\n    };\n    DateFnsUtils.prototype.getMinutes = function (date) {\n        return date.getMinutes();\n    };\n    DateFnsUtils.prototype.getMonth = function (date) {\n        return date.getMonth();\n    };\n    DateFnsUtils.prototype.setMonth = function (date, count) {\n        return setMonth(date, count);\n    };\n    DateFnsUtils.prototype.getMeridiemText = function (ampm) {\n        return ampm === \"am\" ? \"AM\" : \"PM\";\n    };\n    DateFnsUtils.prototype.getNextMonth = function (date) {\n        return addMonths(date, 1);\n    };\n    DateFnsUtils.prototype.getPreviousMonth = function (date) {\n        return addMonths(date, -1);\n    };\n    DateFnsUtils.prototype.getMonthArray = function (date) {\n        var firstMonth = startOfYear(date);\n        var monthArray = [firstMonth];\n        while (monthArray.length < 12) {\n            var prevMonth = monthArray[monthArray.length - 1];\n            monthArray.push(this.getNextMonth(prevMonth));\n        }\n        return monthArray;\n    };\n    DateFnsUtils.prototype.mergeDateAndTime = function (date, time) {\n        return this.setMinutes(this.setHours(date, this.getHours(time)), this.getMinutes(time));\n    };\n    DateFnsUtils.prototype.getWeekdays = function () {\n        var _this = this;\n        var now = new Date();\n        return eachDayOfInterval({\n            start: startOfWeek(now, { locale: this.locale }),\n            end: endOfWeek(now, { locale: this.locale })\n        }).map(function (day) { return _this.format(day, \"EEEEEE\"); });\n    };\n    DateFnsUtils.prototype.getWeekArray = function (date) {\n        var start = startOfWeek(startOfMonth(date), { locale: this.locale });\n        var end = endOfWeek(endOfMonth(date), { locale: this.locale });\n        var count = 0;\n        var current = start;\n        var nestedWeeks = [];\n        while (isBefore(current, end)) {\n            var weekNumber = Math.floor(count / 7);\n            nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];\n            nestedWeeks[weekNumber].push(current);\n            current = addDays(current, 1);\n            count += 1;\n        }\n        return nestedWeeks;\n    };\n    DateFnsUtils.prototype.getYearRange = function (start, end) {\n        var startDate = startOfYear(start);\n        var endDate = endOfYear(end);\n        var years = [];\n        var current = startDate;\n        while (isBefore(current, endDate)) {\n            years.push(current);\n            current = addYears(current, 1);\n        }\n        return years;\n    };\n    // displaying methpds\n    DateFnsUtils.prototype.getCalendarHeaderText = function (date) {\n        return this.format(date, this.yearMonthFormat);\n    };\n    DateFnsUtils.prototype.getYearText = function (date) {\n        return this.format(date, \"yyyy\");\n    };\n    DateFnsUtils.prototype.getDatePickerHeaderText = function (date) {\n        return this.format(date, \"EEE, MMM d\");\n    };\n    DateFnsUtils.prototype.getDateTimePickerHeaderText = function (date) {\n        return this.format(date, \"MMM d\");\n    };\n    DateFnsUtils.prototype.getMonthText = function (date) {\n        return this.format(date, \"MMMM\");\n    };\n    DateFnsUtils.prototype.getDayText = function (date) {\n        return this.format(date, \"d\");\n    };\n    DateFnsUtils.prototype.getHourText = function (date, ampm) {\n        return this.format(date, ampm ? \"hh\" : \"HH\");\n    };\n    DateFnsUtils.prototype.getMinuteText = function (date) {\n        return this.format(date, \"mm\");\n    };\n    DateFnsUtils.prototype.getSecondText = function (date) {\n        return this.format(date, \"ss\");\n    };\n    return DateFnsUtils;\n}());\n\nexport default DateFnsUtils;\n","import memoize from '@emotion/memoize';\n\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|inert|itemProp|itemScope|itemType|itemID|itemRef|on|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar index = memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */\n  && prop.charCodeAt(1) === 110\n  /* n */\n  && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */\n);\n\nexport default index;\n","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _getRequireWildcardCache(nodeInterop) {\n  if (typeof WeakMap !== \"function\") return null;\n  var cacheBabelInterop = new WeakMap();\n  var cacheNodeInterop = new WeakMap();\n  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {\n    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;\n  })(nodeInterop);\n}\nfunction _interopRequireWildcard(obj, nodeInterop) {\n  if (!nodeInterop && obj && obj.__esModule) {\n    return obj;\n  }\n  if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") {\n    return {\n      \"default\": obj\n    };\n  }\n  var cache = _getRequireWildcardCache(nodeInterop);\n  if (cache && cache.has(obj)) {\n    return cache.get(obj);\n  }\n  var newObj = {};\n  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;\n  for (var key in obj) {\n    if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) {\n      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;\n      if (desc && (desc.get || desc.set)) {\n        Object.defineProperty(newObj, key, desc);\n      } else {\n        newObj[key] = obj[key];\n      }\n    }\n  }\n  newObj[\"default\"] = obj;\n  if (cache) {\n    cache.set(obj, newObj);\n  }\n  return newObj;\n}\nmodule.exports = _interopRequireWildcard, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}\nmodule.exports = _inheritsLoose, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _setPrototypeOf(o, p);\n}\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","export default function _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar toPrimitive = require(\"./toPrimitive.js\");\nfunction _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}\nmodule.exports = _toPropertyKey, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nmodule.exports = _toPrimitive, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\nmodule.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/**\n * @license\n * Copyright 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} 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  /**\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","/**\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 { InstantiationMode, Name, NameServiceMapping } 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\n  constructor(\n    private readonly name: T,\n    private readonly container: ComponentContainer\n  ) {}\n\n  /**\n   * @param identifier A provider can provide mulitple instances of a service\n   * if this.component.multipleInstances is true.\n   */\n  get(identifier: string = DEFAULT_ENTRY_NAME): 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      // If the service instance is available, resolve the promise with it immediately\n      try {\n        const instance = this.getOrInitializeService(normalizedIdentifier);\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    return this.instancesDeferred.get(normalizedIdentifier)!.promise;\n  }\n\n  /**\n   *\n   * @param options.identifier A provider can provide mulitple 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    const { identifier, optional } = {\n      identifier: DEFAULT_ENTRY_NAME,\n      optional: false,\n      ...options\n    };\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    try {\n      const instance = this.getOrInitializeService(normalizedIdentifier);\n\n      if (!instance) {\n        if (optional) {\n          return null;\n        }\n        throw Error(`Service ${this.name} is not available`);\n      }\n      return instance;\n    } catch (e) {\n      if (optional) {\n        return null;\n      } else {\n        throw e;\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    // if the service is eager, initialize the default instance\n    if (isComponentEager(component)) {\n      try {\n        this.getOrInitializeService(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 = this.normalizeInstanceIdentifier(\n        instanceIdentifier\n      );\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(normalizedIdentifier)!;\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.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  private getOrInitializeService(\n    identifier: string\n  ): NameServiceMapping[T] | null {\n    let instance = this.instances.get(identifier);\n    if (!instance && this.component) {\n      instance = this.component.instanceFactory(\n        this.container,\n        normalizeIdentifierForFactory(identifier)\n      ) as NameServiceMapping[T];\n      this.instances.set(identifier, instance);\n    }\n\n    return instance || null;\n  }\n\n  private normalizeInstanceIdentifier(identifier: string): 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\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(component: Component<Name>): 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\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\nimport { name as appName } from '../package.json';\nimport { name as analyticsName } from '../../analytics/package.json';\nimport { name as authName } from '../../auth/package.json';\nimport { name as databaseName } from '../../database/package.json';\nimport { name as functionsName } from '../../functions/package.json';\nimport { name as installationsName } from '../../installations/package.json';\nimport { name as messagingName } from '../../messaging/package.json';\nimport { name as performanceName } from '../../performance/package.json';\nimport { name as remoteConfigName } from '../../remote-config/package.json';\nimport { name as storageName } from '../../storage/package.json';\nimport { name as firestoreName } from '../../firestore/package.json';\nimport { name as packageName } from '../../../package.json';\n\nexport const PLATFORM_LOG_STRING = {\n  [appName]: 'fire-core',\n  [analyticsName]: 'fire-analytics',\n  [authName]: 'fire-auth',\n  [databaseName]: 'fire-rtdb',\n  [functionsName]: 'fire-fn',\n  [installationsName]: 'fire-iid',\n  [messagingName]: 'fire-fcm',\n  [performanceName]: 'fire-perf',\n  [remoteConfigName]: 'fire-rc',\n  [storageName]: 'fire-gcs',\n  [firestoreName]: 'fire-fst',\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 { 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 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);\n\n    return provider as Provider<T>;\n  }\n\n  getProviders(): Array<Provider<Name>> {\n    return Array.from(this.providers.values());\n  }\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under the License\n * is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\n * or implied. See the License for the specific language governing permissions and limitations under\n * the License.\n */\n\nimport {\n  CONSOLE_CAMPAIGN_ANALYTICS_ENABLED,\n  CONSOLE_CAMPAIGN_ID,\n  CONSOLE_CAMPAIGN_NAME,\n  CONSOLE_CAMPAIGN_TIME\n} from '../util/constants';\n\nexport interface MessagePayloadInternal {\n  notification?: NotificationPayloadInternal;\n  data?: unknown;\n  fcmOptions?: FcmOptionsInternal;\n  messageType?: MessageType;\n  isFirebaseMessaging?: boolean;\n  from: string;\n  // eslint-disable-next-line camelcase\n  collapse_key: string;\n}\n\nexport interface NotificationPayloadInternal extends NotificationOptions {\n  title: string;\n  // Supported in the Legacy Send API.\n  // See:https://firebase.google.com/docs/cloud-messaging/xmpp-server-ref.\n  // eslint-disable-next-line camelcase\n  click_action?: string;\n}\n\n// Defined in\n// https://firebase.google.com/docs/reference/fcm/rest/v1/projects.messages#webpushfcmoptions. Note\n// that the keys are sent to the clients in snake cases which we need to convert to camel so it can\n// be exposed as a type to match the Firebase API convention.\nexport interface FcmOptionsInternal {\n  link?: string;\n\n  // eslint-disable-next-line camelcase\n  analytics_label?: string;\n}\n\nexport enum MessageType {\n  PUSH_RECEIVED = 'push-received',\n  NOTIFICATION_CLICKED = 'notification-clicked'\n}\n\n/** Additional data of a message sent from the FN Console. */\nexport interface ConsoleMessageData {\n  [CONSOLE_CAMPAIGN_ID]: string;\n  [CONSOLE_CAMPAIGN_TIME]: string;\n  [CONSOLE_CAMPAIGN_NAME]?: string;\n  [CONSOLE_CAMPAIGN_ANALYTICS_ENABLED]?: '1';\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 arrayToBase64(array: Uint8Array | ArrayBuffer): string {\n  const uint8Array = new Uint8Array(array);\n  const base64String = btoa(String.fromCharCode(...uint8Array));\n  return base64String.replace(/=/g, '').replace(/\\+/g, '-').replace(/\\//g, '_');\n}\n\nexport function base64ToArray(base64String: string): Uint8Array {\n  const padding = '='.repeat((4 - (base64String.length % 4)) % 4);\n  const base64 = (base64String + padding)\n    .replace(/\\-/g, '+')\n    .replace(/_/g, '/');\n\n  const rawData = atob(base64);\n  const outputArray = new Uint8Array(rawData.length);\n\n  for (let i = 0; i < rawData.length; ++i) {\n    outputArray[i] = rawData.charCodeAt(i);\n  }\n  return outputArray;\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 { deleteDb, openDb } from 'idb';\n\nimport { TokenDetails } from '../interfaces/token-details';\nimport { arrayToBase64 } from './array-base64-translator';\n\n// https://github.com/firebase/firebase-js-sdk/blob/7857c212f944a2a9eb421fd4cb7370181bc034b5/packages/messaging/src/interfaces/token-details.ts\nexport interface V2TokenDetails {\n  fcmToken: string;\n  swScope: string;\n  vapidKey: string | Uint8Array;\n  subscription: PushSubscription;\n  fcmSenderId: string;\n  fcmPushSet: string;\n  createTime?: number;\n  endpoint?: string;\n  auth?: string;\n  p256dh?: string;\n}\n\n// https://github.com/firebase/firebase-js-sdk/blob/6b5b15ce4ea3df5df5df8a8b33a4e41e249c7715/packages/messaging/src/interfaces/token-details.ts\nexport interface V3TokenDetails {\n  fcmToken: string;\n  swScope: string;\n  vapidKey: Uint8Array;\n  fcmSenderId: string;\n  fcmPushSet: string;\n  endpoint: string;\n  auth: ArrayBuffer;\n  p256dh: ArrayBuffer;\n  createTime: number;\n}\n\n// https://github.com/firebase/firebase-js-sdk/blob/9567dba664732f681fa7fe60f5b7032bb1daf4c9/packages/messaging/src/interfaces/token-details.ts\nexport interface V4TokenDetails {\n  fcmToken: string;\n  swScope: string;\n  vapidKey: Uint8Array;\n  fcmSenderId: string;\n  endpoint: string;\n  auth: ArrayBufferLike;\n  p256dh: ArrayBufferLike;\n  createTime: number;\n}\n\nconst OLD_DB_NAME = 'fcm_token_details_db';\n/**\n * The last DB version of 'fcm_token_details_db' was 4. This is one higher, so that the upgrade\n * callback is called for all versions of the old DB.\n */\nconst OLD_DB_VERSION = 5;\nconst OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store';\n\nexport async function migrateOldDatabase(\n  senderId: string\n): Promise<TokenDetails | null> {\n  if ('databases' in indexedDB) {\n    // indexedDb.databases() is an IndexedDB v3 API and does not exist in all browsers. TODO: Remove\n    // typecast when it lands in TS types.\n    const databases = await (indexedDB as {\n      databases(): Promise<Array<{ name: string; version: number }>>;\n    }).databases();\n    const dbNames = databases.map(db => db.name);\n\n    if (!dbNames.includes(OLD_DB_NAME)) {\n      // old DB didn't exist, no need to open.\n      return null;\n    }\n  }\n\n  let tokenDetails: TokenDetails | null = null;\n\n  const db = await openDb(OLD_DB_NAME, OLD_DB_VERSION, async db => {\n    if (db.oldVersion < 2) {\n      // Database too old, skip migration.\n      return;\n    }\n\n    if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) {\n      // Database did not exist. Nothing to do.\n      return;\n    }\n\n    const objectStore = db.transaction.objectStore(OLD_OBJECT_STORE_NAME);\n    const value = await objectStore.index('fcmSenderId').get(senderId);\n    await objectStore.clear();\n\n    if (!value) {\n      // No entry in the database, nothing to migrate.\n      return;\n    }\n\n    if (db.oldVersion === 2) {\n      const oldDetails = value as V2TokenDetails;\n\n      if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) {\n        return;\n      }\n\n      tokenDetails = {\n        token: oldDetails.fcmToken,\n        createTime: oldDetails.createTime ?? Date.now(),\n        subscriptionOptions: {\n          auth: oldDetails.auth,\n          p256dh: oldDetails.p256dh,\n          endpoint: oldDetails.endpoint,\n          swScope: oldDetails.swScope,\n          vapidKey:\n            typeof oldDetails.vapidKey === 'string'\n              ? oldDetails.vapidKey\n              : arrayToBase64(oldDetails.vapidKey)\n        }\n      };\n    } else if (db.oldVersion === 3) {\n      const oldDetails = value as V3TokenDetails;\n\n      tokenDetails = {\n        token: oldDetails.fcmToken,\n        createTime: oldDetails.createTime,\n        subscriptionOptions: {\n          auth: arrayToBase64(oldDetails.auth),\n          p256dh: arrayToBase64(oldDetails.p256dh),\n          endpoint: oldDetails.endpoint,\n          swScope: oldDetails.swScope,\n          vapidKey: arrayToBase64(oldDetails.vapidKey)\n        }\n      };\n    } else if (db.oldVersion === 4) {\n      const oldDetails = value as V4TokenDetails;\n\n      tokenDetails = {\n        token: oldDetails.fcmToken,\n        createTime: oldDetails.createTime,\n        subscriptionOptions: {\n          auth: arrayToBase64(oldDetails.auth),\n          p256dh: arrayToBase64(oldDetails.p256dh),\n          endpoint: oldDetails.endpoint,\n          swScope: oldDetails.swScope,\n          vapidKey: arrayToBase64(oldDetails.vapidKey)\n        }\n      };\n    }\n  });\n  db.close();\n\n  // Delete all old databases.\n  await deleteDb(OLD_DB_NAME);\n  await deleteDb('fcm_vapid_details_db');\n  await deleteDb('undefined');\n\n  return checkTokenDetails(tokenDetails) ? tokenDetails : null;\n}\n\nfunction checkTokenDetails(\n  tokenDetails: TokenDetails | null\n): tokenDetails is TokenDetails {\n  if (!tokenDetails || !tokenDetails.subscriptionOptions) {\n    return false;\n  }\n  const { subscriptionOptions } = tokenDetails;\n  return (\n    typeof tokenDetails.createTime === 'number' &&\n    tokenDetails.createTime > 0 &&\n    typeof tokenDetails.token === 'string' &&\n    tokenDetails.token.length > 0 &&\n    typeof subscriptionOptions.auth === 'string' &&\n    subscriptionOptions.auth.length > 0 &&\n    typeof subscriptionOptions.p256dh === 'string' &&\n    subscriptionOptions.p256dh.length > 0 &&\n    typeof subscriptionOptions.endpoint === 'string' &&\n    subscriptionOptions.endpoint.length > 0 &&\n    typeof subscriptionOptions.swScope === 'string' &&\n    subscriptionOptions.swScope.length > 0 &&\n    typeof subscriptionOptions.vapidKey === 'string' &&\n    subscriptionOptions.vapidKey.length > 0\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 { DEFAULT_VAPID_KEY, ENDPOINT } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { SubscriptionOptions, TokenDetails } from '../interfaces/token-details';\n\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\n\nexport interface ApiResponse {\n  token?: string;\n  error?: { message: string };\n}\n\nexport interface ApiRequestBody {\n  web: {\n    endpoint: string;\n    p256dh: string;\n    auth: string;\n    applicationPubKey?: string;\n  };\n}\n\nexport async function requestGetToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  subscriptionOptions: SubscriptionOptions\n): Promise<string> {\n  const headers = await getHeaders(firebaseDependencies);\n  const body = getBody(subscriptionOptions);\n\n  const subscribeOptions = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  let responseData: ApiResponse;\n  try {\n    const response = await fetch(\n      getEndpoint(firebaseDependencies.appConfig),\n      subscribeOptions\n    );\n    responseData = await response.json();\n  } catch (err) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_SUBSCRIBE_FAILED, {\n      errorInfo: err\n    });\n  }\n\n  if (responseData.error) {\n    const message = responseData.error.message;\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_SUBSCRIBE_FAILED, {\n      errorInfo: message\n    });\n  }\n\n  if (!responseData.token) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN);\n  }\n\n  return responseData.token;\n}\n\nexport async function requestUpdateToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  tokenDetails: TokenDetails\n): Promise<string> {\n  const headers = await getHeaders(firebaseDependencies);\n  const body = getBody(tokenDetails.subscriptionOptions!);\n\n  const updateOptions = {\n    method: 'PATCH',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  let responseData: ApiResponse;\n  try {\n    const response = await fetch(\n      `${getEndpoint(firebaseDependencies.appConfig)}/${tokenDetails.token}`,\n      updateOptions\n    );\n    responseData = await response.json();\n  } catch (err) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UPDATE_FAILED, {\n      errorInfo: err\n    });\n  }\n\n  if (responseData.error) {\n    const message = responseData.error.message;\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UPDATE_FAILED, {\n      errorInfo: message\n    });\n  }\n\n  if (!responseData.token) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UPDATE_NO_TOKEN);\n  }\n\n  return responseData.token;\n}\n\nexport async function requestDeleteToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  token: string\n): Promise<void> {\n  const headers = await getHeaders(firebaseDependencies);\n\n  const unsubscribeOptions = {\n    method: 'DELETE',\n    headers\n  };\n\n  try {\n    const response = await fetch(\n      `${getEndpoint(firebaseDependencies.appConfig)}/${token}`,\n      unsubscribeOptions\n    );\n    const responseData: ApiResponse = await response.json();\n    if (responseData.error) {\n      const message = responseData.error.message;\n      throw ERROR_FACTORY.create(ErrorCode.TOKEN_UNSUBSCRIBE_FAILED, {\n        errorInfo: message\n      });\n    }\n  } catch (err) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UNSUBSCRIBE_FAILED, {\n      errorInfo: err\n    });\n  }\n}\n\nfunction getEndpoint({ projectId }: AppConfig): string {\n  return `${ENDPOINT}/projects/${projectId!}/registrations`;\n}\n\nasync function getHeaders({\n  appConfig,\n  installations\n}: FirebaseInternalDependencies): Promise<Headers> {\n  const authToken = await installations.getToken();\n\n  return new Headers({\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n    'x-goog-api-key': appConfig.apiKey!,\n    'x-goog-firebase-installations-auth': `FIS ${authToken}`\n  });\n}\n\nfunction getBody({\n  p256dh,\n  auth,\n  endpoint,\n  vapidKey\n}: SubscriptionOptions): ApiRequestBody {\n  const body: ApiRequestBody = {\n    web: {\n      endpoint,\n      auth,\n      p256dh\n    }\n  };\n\n  if (vapidKey !== DEFAULT_VAPID_KEY) {\n    body.web.applicationPubKey = vapidKey;\n  }\n\n  return body;\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 { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { SubscriptionOptions, TokenDetails } from '../interfaces/token-details';\nimport {\n  arrayToBase64,\n  base64ToArray\n} from '../helpers/array-base64-translator';\nimport { dbGet, dbRemove, dbSet } from '../helpers/idb-manager';\nimport { requestDeleteToken, requestGetToken, requestUpdateToken } from './api';\n\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\n\n/** UpdateRegistration will be called once every week. */\nconst TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days\n\nexport async function getToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  swRegistration: ServiceWorkerRegistration,\n  vapidKey: string\n): Promise<string> {\n  if (Notification.permission !== 'granted') {\n    throw ERROR_FACTORY.create(ErrorCode.PERMISSION_BLOCKED);\n  }\n\n  // If a PushSubscription exists it's returned, otherwise a new subscription is generated and\n  // returned.\n  const pushSubscription = await getPushSubscription(swRegistration, vapidKey);\n  const tokenDetails = await dbGet(firebaseDependencies);\n\n  const subscriptionOptions: SubscriptionOptions = {\n    vapidKey,\n    swScope: swRegistration.scope,\n    endpoint: pushSubscription.endpoint,\n    auth: arrayToBase64(pushSubscription.getKey('auth')!),\n    p256dh: arrayToBase64(pushSubscription.getKey('p256dh')!)\n  };\n\n  if (!tokenDetails) {\n    // No token, get a new one.\n    return getNewToken(firebaseDependencies, subscriptionOptions);\n  } else if (\n    !isTokenValid(tokenDetails.subscriptionOptions!, subscriptionOptions)\n  ) {\n    // Invalid token, get a new one.\n    try {\n      await requestDeleteToken(firebaseDependencies, tokenDetails.token);\n    } catch (e) {\n      // Suppress errors because of #2364\n      console.warn(e);\n    }\n\n    return getNewToken(firebaseDependencies, subscriptionOptions);\n  } else if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) {\n    // Weekly token refresh\n    return updateToken(\n      {\n        token: tokenDetails.token,\n        createTime: Date.now(),\n        subscriptionOptions\n      },\n      firebaseDependencies,\n      swRegistration\n    );\n  } else {\n    // Valid token, nothing to do.\n    return tokenDetails.token;\n  }\n}\n\n/**\n * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters\n * the push subscription if it exists.\n */\nexport async function deleteToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  swRegistration: ServiceWorkerRegistration\n): Promise<boolean> {\n  const tokenDetails = await dbGet(firebaseDependencies);\n  if (tokenDetails) {\n    await requestDeleteToken(firebaseDependencies, tokenDetails.token);\n    await dbRemove(firebaseDependencies);\n  }\n\n  // Unsubscribe from the push subscription.\n  const pushSubscription = await swRegistration.pushManager.getSubscription();\n  if (pushSubscription) {\n    return pushSubscription.unsubscribe();\n  }\n\n  // If there's no SW, consider it a success.\n  return true;\n}\n\nasync function updateToken(\n  tokenDetails: TokenDetails,\n  firebaseDependencies: FirebaseInternalDependencies,\n  swRegistration: ServiceWorkerRegistration\n): Promise<string> {\n  try {\n    const updatedToken = await requestUpdateToken(\n      firebaseDependencies,\n      tokenDetails\n    );\n\n    const updatedTokenDetails: TokenDetails = {\n      ...tokenDetails,\n      token: updatedToken,\n      createTime: Date.now()\n    };\n\n    await dbSet(firebaseDependencies, updatedTokenDetails);\n    return updatedToken;\n  } catch (e) {\n    await deleteToken(firebaseDependencies, swRegistration);\n    throw e;\n  }\n}\n\nasync function getNewToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  subscriptionOptions: SubscriptionOptions\n): Promise<string> {\n  const token = await requestGetToken(\n    firebaseDependencies,\n    subscriptionOptions\n  );\n  const tokenDetails: TokenDetails = {\n    token,\n    createTime: Date.now(),\n    subscriptionOptions\n  };\n  await dbSet(firebaseDependencies, tokenDetails);\n  return tokenDetails.token;\n}\n\n/**\n * Gets a PushSubscription for the current user.\n */\nasync function getPushSubscription(\n  swRegistration: ServiceWorkerRegistration,\n  vapidKey: string\n): Promise<PushSubscription> {\n  const subscription = await swRegistration.pushManager.getSubscription();\n  if (subscription) {\n    return subscription;\n  }\n  return swRegistration.pushManager.subscribe({\n    userVisibleOnly: true,\n    // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key\n    // submitted to pushManager#subscribe must be of type Uint8Array.\n    applicationServerKey: base64ToArray(vapidKey)\n  });\n}\n\n/**\n * Checks if the saved tokenDetails object matches the configuration provided.\n */\nfunction isTokenValid(\n  dbOptions: SubscriptionOptions,\n  currentOptions: SubscriptionOptions\n): boolean {\n  const isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey;\n  const isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint;\n  const isAuthEqual = currentOptions.auth === dbOptions.auth;\n  const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;\n\n  return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual;\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 { CONSOLE_CAMPAIGN_ID } from '../util/constants';\nimport { ConsoleMessageData } from '../interfaces/internal-message-payload';\n\nexport function isConsoleMessage(data: unknown): data is ConsoleMessageData {\n  // This message has a campaign ID, meaning it was sent using the Firebase Console.\n  return typeof data === 'object' && !!data && CONSOLE_CAMPAIGN_ID in data;\n}\n","/**\n * @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/** Returns a promise that resolves after given time passes. */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise<void>(resolve => {\n    setTimeout(resolve, ms);\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 {\n  BACKGROUND_HANDLE_EXECUTION_TIME_LIMIT_MS,\n  DEFAULT_VAPID_KEY,\n  FCM_MSG,\n  FOREGROUND_HANDLE_PREPARATION_TIME_MS,\n  TAG\n} from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { FirebaseMessaging, MessagePayload } from '@firebase/messaging-types';\nimport {\n  MessagePayloadInternal,\n  MessageType,\n  NotificationPayloadInternal\n} from '../interfaces/internal-message-payload';\nimport { NextFn, Observer, Unsubscribe } from '@firebase/util';\nimport { deleteToken, getToken } from '../core/token-management';\n\nimport { FirebaseApp } from '@firebase/app-types';\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\nimport { FirebaseService } from '@firebase/app-types/private';\nimport { dbGet } from '../helpers/idb-manager';\nimport { externalizePayload } from '../helpers/externalizePayload';\nimport { isConsoleMessage } from '../helpers/is-console-message';\nimport { sleep } from '../helpers/sleep';\n\n// Let TS know that this is a service worker\ndeclare const self: ServiceWorkerGlobalScope;\n\nexport type BgMessageHandler = (payload: MessagePayload) => unknown;\n\nexport class SwController implements FirebaseMessaging, FirebaseService {\n  // A boolean flag to determine wether an app is using onBackgroundMessage or\n  // setBackgroundMessageHandler. onBackgroundMessage will receive a MessagePayload regardless of if\n  // a notification is displayed. Whereas, setBackgroundMessageHandler will swallow the\n  // MessagePayload if a NotificationPayload is included.\n  private isOnBackgroundMessageUsed: boolean | null = null;\n  private vapidKey: string | null = null;\n  private bgMessageHandler:\n    | null\n    | BgMessageHandler\n    | NextFn<MessagePayload>\n    | Observer<MessagePayload> = null;\n\n  constructor(\n    private readonly firebaseDependencies: FirebaseInternalDependencies\n  ) {\n    self.addEventListener('push', e => {\n      e.waitUntil(this.onPush(e));\n    });\n    self.addEventListener('pushsubscriptionchange', e => {\n      e.waitUntil(this.onSubChange(e));\n    });\n    self.addEventListener('notificationclick', e => {\n      e.waitUntil(this.onNotificationClick(e));\n    });\n  }\n\n  get app(): FirebaseApp {\n    return this.firebaseDependencies.app;\n  }\n\n  /**\n   * @deprecated. Use onBackgroundMessage(nextOrObserver: NextFn<object> | Observer<object>):\n   * Unsubscribe instead.\n   *\n   * Calling setBackgroundMessageHandler will opt in to some specific behaviors.\n   *\n   * 1.) If a notification doesn't need to be shown due to a window already being visible, then push\n   * messages will be sent to the page. 2.) If a notification needs to be shown, and the message\n   * contains no notification data this method will be called and the promise it returns will be\n   * passed to event.waitUntil. If you do not set this callback then all push messages will let and\n   * the developer can handle them in a their own 'push' event callback\n   *\n   * @param callback The callback to be called when a push message is received and a notification\n   * must be shown. The callback will be given the data from the push message.\n   */\n  setBackgroundMessageHandler(callback: BgMessageHandler): void {\n    this.isOnBackgroundMessageUsed = false;\n\n    if (!callback || typeof callback !== 'function') {\n      throw ERROR_FACTORY.create(ErrorCode.INVALID_BG_HANDLER);\n    }\n\n    this.bgMessageHandler = callback;\n  }\n\n  onBackgroundMessage(\n    nextOrObserver: NextFn<MessagePayload> | Observer<MessagePayload>\n  ): Unsubscribe {\n    this.isOnBackgroundMessageUsed = true;\n    this.bgMessageHandler = nextOrObserver;\n\n    return () => {\n      this.bgMessageHandler = null;\n    };\n  }\n\n  // TODO: Remove getToken from SW Controller. Calling this from an old SW can cause all kinds of\n  // trouble.\n  async getToken(): Promise<string> {\n    if (!this.vapidKey) {\n      // Call getToken using the current VAPID key if there already is a token. This is needed\n      // because usePublicVapidKey was not available in SW. It will be removed when vapidKey becomes\n      // a parameter of getToken, or when getToken is removed from SW.\n      const tokenDetails = await dbGet(this.firebaseDependencies);\n      this.vapidKey =\n        tokenDetails?.subscriptionOptions?.vapidKey ?? DEFAULT_VAPID_KEY;\n    }\n\n    return getToken(\n      this.firebaseDependencies,\n      self.registration,\n      this.vapidKey\n    );\n  }\n\n  // TODO: Remove deleteToken from SW Controller. Calling this from an old SW can cause all kinds of\n  // trouble.\n  deleteToken(): Promise<boolean> {\n    return deleteToken(this.firebaseDependencies, self.registration);\n  }\n\n  requestPermission(): Promise<void> {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_WINDOW);\n  }\n\n  // TODO: Remove this together with getToken from SW Controller.\n  usePublicVapidKey(vapidKey: string): void {\n    if (this.vapidKey !== null) {\n      throw ERROR_FACTORY.create(ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN);\n    }\n\n    if (typeof vapidKey !== 'string' || vapidKey.length === 0) {\n      throw ERROR_FACTORY.create(ErrorCode.INVALID_VAPID_KEY);\n    }\n\n    this.vapidKey = vapidKey;\n  }\n\n  useServiceWorker(): void {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_WINDOW);\n  }\n\n  onMessage(): Unsubscribe {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_WINDOW);\n  }\n\n  onTokenRefresh(): Unsubscribe {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_WINDOW);\n  }\n\n  /**\n   * A handler for push events that shows notifications based on the content of the payload.\n   *\n   * The payload must be a JSON-encoded Object with a `notification` key. The value of the\n   * `notification` property will be used as the NotificationOptions object passed to\n   * showNotification. Additionally, the `title` property of the notification object will be used as\n   * the title.\n   *\n   * If there is no notification data in the payload then no notification will be shown.\n   */\n  async onPush(event: PushEvent): Promise<void> {\n    const internalPayload = getMessagePayloadInternal(event);\n    if (!internalPayload) {\n      console.debug(\n        TAG +\n          'failed to get parsed MessagePayload from the PushEvent. Skip handling the push.'\n      );\n      return;\n    }\n\n    // foreground handling: eventually passed to onMessage hook\n    const clientList = await getClientList();\n    if (hasVisibleClients(clientList)) {\n      return sendMessagePayloadInternalToWindows(clientList, internalPayload);\n    }\n\n    // background handling: display and pass to onBackgroundMessage hook\n    let isNotificationShown = false;\n    if (!!internalPayload.notification) {\n      await showNotification(wrapInternalPayload(internalPayload));\n      isNotificationShown = true;\n    }\n\n    // MessagePayload is only passed to `onBackgroundMessage`. Skip passing MessagePayload for\n    // the legacy `setBackgroundMessageHandler` to preserve the SDK behaviors.\n    if (\n      isNotificationShown === true &&\n      this.isOnBackgroundMessageUsed === false\n    ) {\n      return;\n    }\n\n    if (!!this.bgMessageHandler) {\n      const payload = externalizePayload(internalPayload);\n\n      if (typeof this.bgMessageHandler === 'function') {\n        this.bgMessageHandler(payload);\n      } else {\n        this.bgMessageHandler.next(payload);\n      }\n    }\n\n    // wait briefly to allow onBackgroundMessage to complete\n    await sleep(BACKGROUND_HANDLE_EXECUTION_TIME_LIMIT_MS);\n  }\n\n  async onSubChange(event: PushSubscriptionChangeEvent): Promise<void> {\n    const { newSubscription } = event;\n    if (!newSubscription) {\n      // Subscription revoked, delete token\n      await deleteToken(this.firebaseDependencies, self.registration);\n      return;\n    }\n\n    const tokenDetails = await dbGet(this.firebaseDependencies);\n    await deleteToken(this.firebaseDependencies, self.registration);\n    await getToken(\n      this.firebaseDependencies,\n      self.registration,\n      tokenDetails?.subscriptionOptions?.vapidKey ?? DEFAULT_VAPID_KEY\n    );\n  }\n\n  async onNotificationClick(event: NotificationEvent): Promise<void> {\n    const internalPayload: MessagePayloadInternal =\n      event.notification?.data?.[FCM_MSG];\n\n    if (!internalPayload) {\n      return;\n    } else if (event.action) {\n      // User clicked on an action button. This will allow developers to act on action button clicks\n      // by using a custom onNotificationClick listener that they define.\n      return;\n    }\n\n    // Prevent other listeners from receiving the event\n    event.stopImmediatePropagation();\n    event.notification.close();\n\n    // Note clicking on a notification with no link set will focus the Chrome's current tab.\n    const link = getLink(internalPayload);\n    if (!link) {\n      return;\n    }\n\n    // FM should only open/focus links from app's origin.\n    const url = new URL(link, self.location.href);\n    const originUrl = new URL(self.location.origin);\n\n    if (url.host !== originUrl.host) {\n      return;\n    }\n\n    let client = await getWindowClient(url);\n\n    if (!client) {\n      client = await self.clients.openWindow(link);\n\n      // Wait three seconds for the client to initialize and set up the message handler so that it\n      // can receive the message.\n      await sleep(FOREGROUND_HANDLE_PREPARATION_TIME_MS);\n    } else {\n      client = await client.focus();\n    }\n\n    if (!client) {\n      // Window Client will not be returned if it's for a third party origin.\n      return;\n    }\n\n    internalPayload.messageType = MessageType.NOTIFICATION_CLICKED;\n    internalPayload.isFirebaseMessaging = true;\n    return client.postMessage(internalPayload);\n  }\n}\n\nfunction wrapInternalPayload(\n  internalPayload: MessagePayloadInternal\n): NotificationPayloadInternal {\n  const wrappedInternalPayload: NotificationPayloadInternal = {\n    ...((internalPayload.notification as unknown) as NotificationPayloadInternal)\n  };\n\n  // Put the message payload under FCM_MSG name so we can identify the notification as being an FCM\n  // notification vs a notification from somewhere else (i.e. normal web push or developer generated\n  // notification).\n  wrappedInternalPayload.data = {\n    [FCM_MSG]: internalPayload\n  };\n\n  return wrappedInternalPayload;\n}\n\nfunction getMessagePayloadInternal({\n  data\n}: PushEvent): MessagePayloadInternal | null {\n  if (!data) {\n    return null;\n  }\n\n  try {\n    return data.json();\n  } catch (err) {\n    // Not JSON so not an FCM message.\n    return null;\n  }\n}\n\n/**\n * @param url The URL to look for when focusing a client.\n * @return Returns an existing window client or a newly opened WindowClient.\n */\nasync function getWindowClient(url: URL): Promise<WindowClient | null> {\n  const clientList = await getClientList();\n\n  for (const client of clientList) {\n    const clientUrl = new URL(client.url, self.location.href);\n\n    if (url.host === clientUrl.host) {\n      return client;\n    }\n  }\n\n  return null;\n}\n\n/**\n * @returns If there is currently a visible WindowClient, this method will resolve to true,\n * otherwise false.\n */\nfunction hasVisibleClients(clientList: WindowClient[]): boolean {\n  return clientList.some(\n    client =>\n      client.visibilityState === 'visible' &&\n      // Ignore chrome-extension clients as that matches the background pages of extensions, which\n      // are always considered visible for some reason.\n      !client.url.startsWith('chrome-extension://')\n  );\n}\n\nfunction sendMessagePayloadInternalToWindows(\n  clientList: WindowClient[],\n  internalPayload: MessagePayloadInternal\n): void {\n  internalPayload.isFirebaseMessaging = true;\n  internalPayload.messageType = MessageType.PUSH_RECEIVED;\n\n  for (const client of clientList) {\n    client.postMessage(internalPayload);\n  }\n}\n\nfunction getClientList(): Promise<WindowClient[]> {\n  return self.clients.matchAll({\n    type: 'window',\n    includeUncontrolled: true\n    // TS doesn't know that \"type: 'window'\" means it'll return WindowClient[]\n  }) as Promise<WindowClient[]>;\n}\n\nfunction showNotification(\n  notificationPayloadInternal: NotificationPayloadInternal\n): Promise<void> {\n  // Note: Firefox does not support the maxActions property.\n  // https://developer.mozilla.org/en-US/docs/Web/API/notification/maxActions\n  const { actions } = notificationPayloadInternal;\n  const { maxActions } = Notification;\n  if (actions && maxActions && actions.length > maxActions) {\n    console.warn(\n      `This browser only supports ${maxActions} actions. The remaining actions will not be displayed.`\n    );\n  }\n\n  return self.registration.showNotification(\n    /* title= */ notificationPayloadInternal.title ?? '',\n    notificationPayloadInternal\n  );\n}\n\nfunction getLink(payload: MessagePayloadInternal): string | null {\n  // eslint-disable-next-line camelcase\n  const link = payload.fcmOptions?.link ?? payload.notification?.click_action;\n  if (link) {\n    return link;\n  }\n\n  if (isConsoleMessage(payload.data)) {\n    // Notification created in the Firebase Console. Redirect to origin.\n    return self.location.origin;\n  } else {\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 { MessagePayload } from '@firebase/messaging-types';\nimport { MessagePayloadInternal } from '../interfaces/internal-message-payload';\n\nexport function externalizePayload(\n  internalPayload: MessagePayloadInternal\n): MessagePayload {\n  const payload: MessagePayload = {\n    from: internalPayload.from,\n    // eslint-disable-next-line camelcase\n    collapseKey: internalPayload.collapse_key\n  } as MessagePayload;\n\n  propagateNotificationPayload(payload, internalPayload);\n  propagateDataPayload(payload, internalPayload);\n  propagateFcmOptions(payload, internalPayload);\n\n  return payload;\n}\n\nfunction propagateNotificationPayload(\n  payload: MessagePayload,\n  messagePayloadInternal: MessagePayloadInternal\n): void {\n  if (!messagePayloadInternal.notification) {\n    return;\n  }\n\n  payload.notification = {};\n\n  const title = messagePayloadInternal.notification!.title;\n  if (!!title) {\n    payload.notification!.title = title;\n  }\n\n  const body = messagePayloadInternal.notification!.body;\n  if (!!body) {\n    payload.notification!.body = body;\n  }\n\n  const image = messagePayloadInternal.notification!.image;\n  if (!!image) {\n    payload.notification!.image = image;\n  }\n}\n\nfunction propagateDataPayload(\n  payload: MessagePayload,\n  messagePayloadInternal: MessagePayloadInternal\n): void {\n  if (!messagePayloadInternal.data) {\n    return;\n  }\n\n  payload.data = messagePayloadInternal.data as { [key: string]: string };\n}\n\nfunction propagateFcmOptions(\n  payload: MessagePayload,\n  messagePayloadInternal: MessagePayloadInternal\n): void {\n  if (!messagePayloadInternal.fcmOptions) {\n    return;\n  }\n\n  payload.fcmOptions = {};\n\n  const link = messagePayloadInternal.fcmOptions!.link;\n  if (!!link) {\n    payload.fcmOptions!.link = link;\n  }\n\n  // eslint-disable-next-line camelcase\n  const analyticsLabel = messagePayloadInternal.fcmOptions!.analytics_label;\n  if (!!analyticsLabel) {\n    payload.fcmOptions!.analyticsLabel = analyticsLabel;\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 {\n  CONSOLE_CAMPAIGN_ANALYTICS_ENABLED,\n  CONSOLE_CAMPAIGN_ID,\n  CONSOLE_CAMPAIGN_NAME,\n  CONSOLE_CAMPAIGN_TIME,\n  DEFAULT_SW_PATH,\n  DEFAULT_SW_SCOPE,\n  DEFAULT_VAPID_KEY\n} from '../util/constants';\nimport {\n  ConsoleMessageData,\n  MessagePayloadInternal,\n  MessageType\n} from '../interfaces/internal-message-payload';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { NextFn, Observer, Unsubscribe } from '@firebase/util';\nimport { deleteToken, getToken } from '../core/token-management';\n\nimport { FirebaseApp } from '@firebase/app-types';\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\nimport { FirebaseMessaging } from '@firebase/messaging-types';\nimport { FirebaseService } from '@firebase/app-types/private';\nimport { isConsoleMessage } from '../helpers/is-console-message';\n\nexport class WindowController implements FirebaseMessaging, FirebaseService {\n  private vapidKey: string | null = null;\n  private swRegistration?: ServiceWorkerRegistration;\n  private onMessageCallback: NextFn<object> | Observer<object> | null = null;\n\n  constructor(\n    private readonly firebaseDependencies: FirebaseInternalDependencies\n  ) {\n    navigator.serviceWorker.addEventListener('message', e =>\n      this.messageEventListener(e)\n    );\n  }\n\n  get app(): FirebaseApp {\n    return this.firebaseDependencies.app;\n  }\n\n  private async messageEventListener(event: MessageEvent): Promise<void> {\n    const internalPayload = event.data as MessagePayloadInternal;\n\n    if (!internalPayload.isFirebaseMessaging) {\n      return;\n    }\n\n    // onMessageCallback is either a function or observer/subscriber.\n    // TODO: in the modularization release, have onMessage handle type MessagePayload as supposed to\n    // the legacy payload where some fields are in snake cases.\n    if (\n      this.onMessageCallback &&\n      internalPayload.messageType === MessageType.PUSH_RECEIVED\n    ) {\n      if (typeof this.onMessageCallback === 'function') {\n        this.onMessageCallback(\n          stripInternalFields(Object.assign({}, internalPayload))\n        );\n      } else {\n        this.onMessageCallback.next(Object.assign({}, internalPayload));\n      }\n    }\n\n    const dataPayload = internalPayload.data;\n\n    if (\n      isConsoleMessage(dataPayload) &&\n      dataPayload[CONSOLE_CAMPAIGN_ANALYTICS_ENABLED] === '1'\n    ) {\n      await this.logEvent(internalPayload.messageType!, dataPayload);\n    }\n  }\n\n  getVapidKey(): string | null {\n    return this.vapidKey;\n  }\n\n  getSwReg(): ServiceWorkerRegistration | undefined {\n    return this.swRegistration;\n  }\n\n  async getToken(options?: {\n    vapidKey?: string;\n    serviceWorkerRegistration?: ServiceWorkerRegistration;\n  }): Promise<string> {\n    if (Notification.permission === 'default') {\n      await Notification.requestPermission();\n    }\n\n    if (Notification.permission !== 'granted') {\n      throw ERROR_FACTORY.create(ErrorCode.PERMISSION_BLOCKED);\n    }\n\n    await this.updateVapidKey(options?.vapidKey);\n    await this.updateSwReg(options?.serviceWorkerRegistration);\n\n    return getToken(\n      this.firebaseDependencies,\n      this.swRegistration!,\n      this.vapidKey!\n    );\n  }\n\n  async updateVapidKey(vapidKey?: string | undefined): Promise<void> {\n    if (!!vapidKey) {\n      this.vapidKey = vapidKey;\n    } else if (!this.vapidKey) {\n      this.vapidKey = DEFAULT_VAPID_KEY;\n    }\n  }\n\n  async updateSwReg(\n    swRegistration?: ServiceWorkerRegistration | undefined\n  ): Promise<void> {\n    if (!swRegistration && !this.swRegistration) {\n      await this.registerDefaultSw();\n    }\n\n    if (!swRegistration && !!this.swRegistration) {\n      return;\n    }\n\n    if (!(swRegistration instanceof ServiceWorkerRegistration)) {\n      throw ERROR_FACTORY.create(ErrorCode.INVALID_SW_REGISTRATION);\n    }\n\n    this.swRegistration = swRegistration;\n  }\n\n  private async registerDefaultSw(): Promise<void> {\n    try {\n      this.swRegistration = await navigator.serviceWorker.register(\n        DEFAULT_SW_PATH,\n        {\n          scope: DEFAULT_SW_SCOPE\n        }\n      );\n\n      // The timing when browser updates sw when sw has an update is unreliable by my experiment. It\n      // leads to version conflict when the SDK upgrades to a newer version in the main page, but sw\n      // is stuck with the old version. For example,\n      // https://github.com/firebase/firebase-js-sdk/issues/2590 The following line reliably updates\n      // sw if there was an update.\n      this.swRegistration.update().catch(() => {\n        /* it is non blocking and we don't care if it failed */\n      });\n    } catch (e) {\n      throw ERROR_FACTORY.create(ErrorCode.FAILED_DEFAULT_REGISTRATION, {\n        browserErrorMessage: e.message\n      });\n    }\n  }\n\n  async deleteToken(): Promise<boolean> {\n    if (!this.swRegistration) {\n      await this.registerDefaultSw();\n    }\n\n    return deleteToken(this.firebaseDependencies, this.swRegistration!);\n  }\n\n  /**\n   * Request permission if it is not currently granted.\n   *\n   * @return Resolves if the permission was granted, rejects otherwise.\n   *\n   * @deprecated Use Notification.requestPermission() instead.\n   * https://developer.mozilla.org/en-US/docs/Web/API/Notification/requestPermission\n   */\n  async requestPermission(): Promise<void> {\n    if (Notification.permission === 'granted') {\n      return;\n    }\n\n    const permissionResult = await Notification.requestPermission();\n    if (permissionResult === 'granted') {\n      return;\n    } else if (permissionResult === 'denied') {\n      throw ERROR_FACTORY.create(ErrorCode.PERMISSION_BLOCKED);\n    } else {\n      throw ERROR_FACTORY.create(ErrorCode.PERMISSION_DEFAULT);\n    }\n  }\n\n  /**\n   * @deprecated. Use getToken(options?: {vapidKey?: string; serviceWorkerRegistration?:\n   * ServiceWorkerRegistration;}): Promise<string> instead.\n   */\n  usePublicVapidKey(vapidKey: string): void {\n    if (this.vapidKey !== null) {\n      throw ERROR_FACTORY.create(ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN);\n    }\n\n    if (typeof vapidKey !== 'string' || vapidKey.length === 0) {\n      throw ERROR_FACTORY.create(ErrorCode.INVALID_VAPID_KEY);\n    }\n\n    this.vapidKey = vapidKey;\n  }\n\n  /**\n   * @deprecated. Use getToken(options?: {vapidKey?: string; serviceWorkerRegistration?:\n   * ServiceWorkerRegistration;}): Promise<string> instead.\n   */\n  useServiceWorker(swRegistration: ServiceWorkerRegistration): void {\n    if (!(swRegistration instanceof ServiceWorkerRegistration)) {\n      throw ERROR_FACTORY.create(ErrorCode.INVALID_SW_REGISTRATION);\n    }\n\n    if (this.swRegistration) {\n      throw ERROR_FACTORY.create(ErrorCode.USE_SW_AFTER_GET_TOKEN);\n    }\n\n    this.swRegistration = swRegistration;\n  }\n\n  /**\n   * @param nextOrObserver An observer object or a function triggered on message.\n   *\n   * @return The unsubscribe function for the observer.\n   */\n  onMessage(nextOrObserver: NextFn<object> | Observer<object>): Unsubscribe {\n    this.onMessageCallback = nextOrObserver;\n\n    return () => {\n      this.onMessageCallback = null;\n    };\n  }\n\n  setBackgroundMessageHandler(): void {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_SW);\n  }\n\n  onBackgroundMessage(): Unsubscribe {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_SW);\n  }\n\n  /**\n   * @deprecated No-op. It was initially designed with token rotation requests from server in mind.\n   * However, the plan to implement such feature was abandoned.\n   */\n  onTokenRefresh(): Unsubscribe {\n    return () => {};\n  }\n\n  private async logEvent(\n    messageType: MessageType,\n    data: ConsoleMessageData\n  ): Promise<void> {\n    const eventType = getEventType(messageType);\n    const analytics = await this.firebaseDependencies.analyticsProvider.get();\n    analytics.logEvent(eventType, {\n      /* eslint-disable camelcase */\n      message_id: data[CONSOLE_CAMPAIGN_ID],\n      message_name: data[CONSOLE_CAMPAIGN_NAME],\n      message_time: data[CONSOLE_CAMPAIGN_TIME],\n      message_device_time: Math.floor(Date.now() / 1000)\n      /* eslint-enable camelcase */\n    });\n  }\n}\n\nfunction getEventType(messageType: MessageType): string {\n  switch (messageType) {\n    case MessageType.NOTIFICATION_CLICKED:\n      return 'notification_open';\n    case MessageType.PUSH_RECEIVED:\n      return 'notification_foreground';\n    default:\n      throw new Error();\n  }\n}\n\nfunction stripInternalFields(\n  internalPayload: MessagePayloadInternal\n): MessagePayloadInternal {\n  delete internalPayload.messageType;\n  delete internalPayload.isFirebaseMessaging;\n  return internalPayload;\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\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  DynamicConfig,\n  DataLayer,\n  Gtag,\n  CustomParams,\n  ControlParams,\n  EventParams,\n  MinimalDynamicConfig\n} from '@firebase/analytics-types';\nimport { GtagCommand, GTAG_URL } from './constants';\nimport { logger } from './logger';\n\n/**\n * Inserts gtag script tag into the page to asynchronously download gtag.\n * @param dataLayerName Name of datalayer (most often the default, \"_dataLayer\").\n */\nexport function insertScriptTag(dataLayerName: string): void {\n  const script = document.createElement('script');\n  // We are not providing an analyticsId in the URL because it would trigger a `page_view`\n  // without fid. We will initialize ga-id using gtag (config) command together with fid.\n  script.src = `${GTAG_URL}?l=${dataLayerName}`;\n  script.async = true;\n  document.head.appendChild(script);\n}\n\n/**\n * Get reference to, or create, global datalayer.\n * @param dataLayerName Name of datalayer (most often the default, \"_dataLayer\").\n */\nexport function getOrCreateDataLayer(dataLayerName: string): DataLayer {\n  // Check for existing dataLayer and create if needed.\n  let dataLayer: DataLayer = [];\n  if (Array.isArray(window[dataLayerName])) {\n    dataLayer = window[dataLayerName] as DataLayer;\n  } else {\n    window[dataLayerName] = dataLayer;\n  }\n  return dataLayer;\n}\n\n/**\n * Wrapped gtag logic when gtag is called with 'config' command.\n *\n * @param gtagCore Basic gtag function that just appends to dataLayer.\n * @param initializationPromisesMap Map of appIds to their initialization promises.\n * @param dynamicConfigPromisesList Array of dynamic config fetch promises.\n * @param measurementIdToAppId Map of GA measurementIDs to corresponding Firebase appId.\n * @param measurementId GA Measurement ID to set config for.\n * @param gtagParams Gtag config params to set.\n */\nasync function gtagOnConfig(\n  gtagCore: Gtag,\n  initializationPromisesMap: { [appId: string]: Promise<string> },\n  dynamicConfigPromisesList: Array<\n    Promise<DynamicConfig | MinimalDynamicConfig>\n  >,\n  measurementIdToAppId: { [measurementId: string]: string },\n  measurementId: string,\n  gtagParams?: ControlParams & EventParams & CustomParams\n): Promise<void> {\n  // If config is already fetched, we know the appId and can use it to look up what FID promise we\n  /// are waiting for, and wait only on that one.\n  const correspondingAppId = measurementIdToAppId[measurementId as string];\n  try {\n    if (correspondingAppId) {\n      await initializationPromisesMap[correspondingAppId];\n    } else {\n      // If config is not fetched yet, wait for all configs (we don't know which one we need) and\n      // find the appId (if any) corresponding to this measurementId. If there is one, wait on\n      // that appId's initialization promise. If there is none, promise resolves and gtag\n      // call goes through.\n      const dynamicConfigResults = await Promise.all(dynamicConfigPromisesList);\n      const foundConfig = dynamicConfigResults.find(\n        config => config.measurementId === measurementId\n      );\n      if (foundConfig) {\n        await initializationPromisesMap[foundConfig.appId];\n      }\n    }\n  } catch (e) {\n    logger.error(e);\n  }\n  gtagCore(GtagCommand.CONFIG, measurementId, gtagParams);\n}\n\n/**\n * Wrapped gtag logic when gtag is called with 'event' command.\n *\n * @param gtagCore Basic gtag function that just appends to dataLayer.\n * @param initializationPromisesMap Map of appIds to their initialization promises.\n * @param dynamicConfigPromisesList Array of dynamic config fetch promises.\n * @param measurementId GA Measurement ID to log event to.\n * @param gtagParams Params to log with this event.\n */\nasync function gtagOnEvent(\n  gtagCore: Gtag,\n  initializationPromisesMap: { [appId: string]: Promise<string> },\n  dynamicConfigPromisesList: Array<\n    Promise<DynamicConfig | MinimalDynamicConfig>\n  >,\n  measurementId: string,\n  gtagParams?: ControlParams & EventParams & CustomParams\n): Promise<void> {\n  try {\n    let initializationPromisesToWaitFor: Array<Promise<string>> = [];\n\n    // If there's a 'send_to' param, check if any ID specified matches\n    // an initializeIds() promise we are waiting for.\n    if (gtagParams && gtagParams['send_to']) {\n      let gaSendToList: string | string[] = gtagParams['send_to'];\n      // Make it an array if is isn't, so it can be dealt with the same way.\n      if (!Array.isArray(gaSendToList)) {\n        gaSendToList = [gaSendToList];\n      }\n      // Checking 'send_to' fields requires having all measurement ID results back from\n      // the dynamic config fetch.\n      const dynamicConfigResults = await Promise.all(dynamicConfigPromisesList);\n      for (const sendToId of gaSendToList) {\n        // Any fetched dynamic measurement ID that matches this 'send_to' ID\n        const foundConfig = dynamicConfigResults.find(\n          config => config.measurementId === sendToId\n        );\n        const initializationPromise =\n          foundConfig && initializationPromisesMap[foundConfig.appId];\n        if (initializationPromise) {\n          initializationPromisesToWaitFor.push(initializationPromise);\n        } else {\n          // Found an item in 'send_to' that is not associated\n          // directly with an FID, possibly a group.  Empty this array,\n          // exit the loop early, and let it get populated below.\n          initializationPromisesToWaitFor = [];\n          break;\n        }\n      }\n    }\n\n    // This will be unpopulated if there was no 'send_to' field , or\n    // if not all entries in the 'send_to' field could be mapped to\n    // a FID. In these cases, wait on all pending initialization promises.\n    if (initializationPromisesToWaitFor.length === 0) {\n      initializationPromisesToWaitFor = Object.values(\n        initializationPromisesMap\n      );\n    }\n\n    // Run core gtag function with args after all relevant initialization\n    // promises have been resolved.\n    await Promise.all(initializationPromisesToWaitFor);\n    // Workaround for http://b/141370449 - third argument cannot be undefined.\n    gtagCore(GtagCommand.EVENT, measurementId, gtagParams || {});\n  } catch (e) {\n    logger.error(e);\n  }\n}\n\n/**\n * Wraps a standard gtag function with extra code to wait for completion of\n * relevant initialization promises before sending requests.\n *\n * @param gtagCore Basic gtag function that just appends to dataLayer.\n * @param initializationPromisesMap Map of appIds to their initialization promises.\n * @param dynamicConfigPromisesList Array of dynamic config fetch promises.\n * @param measurementIdToAppId Map of GA measurementIDs to corresponding Firebase appId.\n */\nfunction wrapGtag(\n  gtagCore: Gtag,\n  /**\n   * Allows wrapped gtag calls to wait on whichever intialization promises are required,\n   * depending on the contents of the gtag params' `send_to` field, if any.\n   */\n  initializationPromisesMap: { [appId: string]: Promise<string> },\n  /**\n   * Wrapped gtag calls sometimes require all dynamic config fetches to have returned\n   * before determining what initialization promises (which include FIDs) to wait for.\n   */\n  dynamicConfigPromisesList: Array<\n    Promise<DynamicConfig | MinimalDynamicConfig>\n  >,\n  /**\n   * Wrapped gtag config calls can narrow down which initialization promise (with FID)\n   * to wait for if the measurementId is already fetched, by getting the corresponding appId,\n   * which is the key for the initialization promises map.\n   */\n  measurementIdToAppId: { [measurementId: string]: string }\n): Gtag {\n  /**\n   * Wrapper around gtag that ensures FID is sent with gtag calls.\n   * @param command Gtag command type.\n   * @param idOrNameOrParams Measurement ID if command is EVENT/CONFIG, params if command is SET.\n   * @param gtagParams Params if event is EVENT/CONFIG.\n   */\n  async function gtagWrapper(\n    command: 'config' | 'set' | 'event',\n    idOrNameOrParams: string | ControlParams,\n    gtagParams?: ControlParams & EventParams & CustomParams\n  ): Promise<void> {\n    try {\n      // If event, check that relevant initialization promises have completed.\n      if (command === GtagCommand.EVENT) {\n        // If EVENT, second arg must be measurementId.\n        await gtagOnEvent(\n          gtagCore,\n          initializationPromisesMap,\n          dynamicConfigPromisesList,\n          idOrNameOrParams as string,\n          gtagParams\n        );\n      } else if (command === GtagCommand.CONFIG) {\n        // If CONFIG, second arg must be measurementId.\n        await gtagOnConfig(\n          gtagCore,\n          initializationPromisesMap,\n          dynamicConfigPromisesList,\n          measurementIdToAppId,\n          idOrNameOrParams as string,\n          gtagParams\n        );\n      } else {\n        // If SET, second arg must be params.\n        gtagCore(GtagCommand.SET, idOrNameOrParams as CustomParams);\n      }\n    } catch (e) {\n      logger.error(e);\n    }\n  }\n  return gtagWrapper;\n}\n\n/**\n * Creates global gtag function or wraps existing one if found.\n * This wrapped function attaches Firebase instance ID (FID) to gtag 'config' and\n * 'event' calls that belong to the GAID associated with this Firebase instance.\n *\n * @param initializationPromisesMap Map of appIds to their initialization promises.\n * @param dynamicConfigPromisesList Array of dynamic config fetch promises.\n * @param measurementIdToAppId Map of GA measurementIDs to corresponding Firebase appId.\n * @param dataLayerName Name of global GA datalayer array.\n * @param gtagFunctionName Name of global gtag function (\"gtag\" if not user-specified).\n */\nexport function wrapOrCreateGtag(\n  initializationPromisesMap: { [appId: string]: Promise<string> },\n  dynamicConfigPromisesList: Array<\n    Promise<DynamicConfig | MinimalDynamicConfig>\n  >,\n  measurementIdToAppId: { [measurementId: string]: string },\n  dataLayerName: string,\n  gtagFunctionName: string\n): {\n  gtagCore: Gtag;\n  wrappedGtag: Gtag;\n} {\n  // Create a basic core gtag function\n  let gtagCore: Gtag = function (..._args: unknown[]) {\n    // Must push IArguments object, not an array.\n    (window[dataLayerName] as DataLayer).push(arguments);\n  };\n\n  // Replace it with existing one if found\n  if (\n    window[gtagFunctionName] &&\n    typeof window[gtagFunctionName] === 'function'\n  ) {\n    // @ts-ignore\n    gtagCore = window[gtagFunctionName];\n  }\n\n  window[gtagFunctionName] = wrapGtag(\n    gtagCore,\n    initializationPromisesMap,\n    dynamicConfigPromisesList,\n    measurementIdToAppId\n  );\n\n  return {\n    gtagCore,\n    wrappedGtag: window[gtagFunctionName] as Gtag\n  };\n}\n\n/**\n * Returns first script tag in DOM matching our gtag url pattern.\n */\nexport function findGtagScriptOnPage(): HTMLScriptElement | null {\n  const scriptTags = window.document.getElementsByTagName('script');\n  for (const tag of Object.values(scriptTags)) {\n    if (tag.src && tag.src.includes(GTAG_URL)) {\n      return tag;\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\n/**\n * @fileoverview Most logic is copied from packages/remote-config/src/client/retrying_client.ts\n */\n\nimport { FirebaseApp } from '@firebase/app-types';\nimport {\n  DynamicConfig,\n  ThrottleMetadata,\n  MinimalDynamicConfig\n} from '@firebase/analytics-types';\nimport { FirebaseError, calculateBackoffMillis } from '@firebase/util';\nimport { AnalyticsError, ERROR_FACTORY } from './errors';\nimport { DYNAMIC_CONFIG_URL, FETCH_TIMEOUT_MILLIS } from './constants';\nimport { logger } from './logger';\n\n// App config fields needed by analytics.\nexport interface AppFields {\n  appId: string;\n  apiKey: string;\n  measurementId?: string;\n}\n\n/**\n * Backoff factor for 503 errors, which we want to be conservative about\n * to avoid overloading servers. Each retry interval will be\n * BASE_INTERVAL_MILLIS * LONG_RETRY_FACTOR ^ retryCount, so the second one\n * will be ~30 seconds (with fuzzing).\n */\nexport const LONG_RETRY_FACTOR = 30;\n\n/**\n * Base wait interval to multiplied by backoffFactor^backoffCount.\n */\nconst BASE_INTERVAL_MILLIS = 1000;\n\n/**\n * Stubbable retry data storage class.\n */\nclass RetryData {\n  constructor(\n    public throttleMetadata: { [appId: string]: ThrottleMetadata } = {},\n    public intervalMillis: number = BASE_INTERVAL_MILLIS\n  ) {}\n\n  getThrottleMetadata(appId: string): ThrottleMetadata {\n    return this.throttleMetadata[appId];\n  }\n\n  setThrottleMetadata(appId: string, metadata: ThrottleMetadata): void {\n    this.throttleMetadata[appId] = metadata;\n  }\n\n  deleteThrottleMetadata(appId: string): void {\n    delete this.throttleMetadata[appId];\n  }\n}\n\nconst defaultRetryData = new RetryData();\n\n/**\n * Set GET request headers.\n * @param apiKey App API key.\n */\nfunction getHeaders(apiKey: string): Headers {\n  return new Headers({\n    Accept: 'application/json',\n    'x-goog-api-key': apiKey\n  });\n}\n\n/**\n * Fetches dynamic config from backend.\n * @param app Firebase app to fetch config for.\n */\nexport async function fetchDynamicConfig(\n  appFields: AppFields\n): Promise<DynamicConfig> {\n  const { appId, apiKey } = appFields;\n  const request: RequestInit = {\n    method: 'GET',\n    headers: getHeaders(apiKey)\n  };\n  const appUrl = DYNAMIC_CONFIG_URL.replace('{app-id}', appId);\n  const response = await fetch(appUrl, request);\n  if (response.status !== 200 && response.status !== 304) {\n    let errorMessage = '';\n    try {\n      // Try to get any error message text from server response.\n      const jsonResponse = (await response.json()) as {\n        error?: { message?: string };\n      };\n      if (jsonResponse.error?.message) {\n        errorMessage = jsonResponse.error.message;\n      }\n    } catch (_ignored) {}\n    throw ERROR_FACTORY.create(AnalyticsError.CONFIG_FETCH_FAILED, {\n      httpStatus: response.status,\n      responseMessage: errorMessage\n    });\n  }\n  return response.json();\n}\n\n/**\n * Fetches dynamic config from backend, retrying if failed.\n * @param app Firebase app to fetch config for.\n */\nexport async function fetchDynamicConfigWithRetry(\n  app: FirebaseApp,\n  // retryData and timeoutMillis are parameterized to allow passing a different value for testing.\n  retryData: RetryData = defaultRetryData,\n  timeoutMillis?: number\n): Promise<DynamicConfig | MinimalDynamicConfig> {\n  const { appId, apiKey, measurementId } = app.options;\n\n  if (!appId) {\n    throw ERROR_FACTORY.create(AnalyticsError.NO_APP_ID);\n  }\n\n  if (!apiKey) {\n    if (measurementId) {\n      return {\n        measurementId,\n        appId\n      };\n    }\n    throw ERROR_FACTORY.create(AnalyticsError.NO_API_KEY);\n  }\n\n  const throttleMetadata: ThrottleMetadata = retryData.getThrottleMetadata(\n    appId\n  ) || {\n    backoffCount: 0,\n    throttleEndTimeMillis: Date.now()\n  };\n\n  const signal = new AnalyticsAbortSignal();\n\n  setTimeout(\n    async () => {\n      // Note a very low delay, eg < 10ms, can elapse before listeners are initialized.\n      signal.abort();\n    },\n    timeoutMillis !== undefined ? timeoutMillis : FETCH_TIMEOUT_MILLIS\n  );\n\n  return attemptFetchDynamicConfigWithRetry(\n    { appId, apiKey, measurementId },\n    throttleMetadata,\n    signal,\n    retryData\n  );\n}\n\n/**\n * Runs one retry attempt.\n * @param appFields Necessary app config fields.\n * @param throttleMetadata Ongoing metadata to determine throttling times.\n * @param signal Abort signal.\n */\nasync function attemptFetchDynamicConfigWithRetry(\n  appFields: AppFields,\n  { throttleEndTimeMillis, backoffCount }: ThrottleMetadata,\n  signal: AnalyticsAbortSignal,\n  retryData: RetryData = defaultRetryData // for testing\n): Promise<DynamicConfig | MinimalDynamicConfig> {\n  const { appId, measurementId } = appFields;\n  // Starts with a (potentially zero) timeout to support resumption from stored state.\n  // Ensures the throttle end time is honored if the last attempt timed out.\n  // Note the SDK will never make a request if the fetch timeout expires at this point.\n  try {\n    await setAbortableTimeout(signal, throttleEndTimeMillis);\n  } catch (e) {\n    if (measurementId) {\n      logger.warn(\n        `Timed out fetching this Firebase app's measurement ID from the server.` +\n          ` Falling back to the measurement ID ${measurementId}` +\n          ` provided in the \"measurementId\" field in the local Firebase config. [${e.message}]`\n      );\n      return { appId, measurementId };\n    }\n    throw e;\n  }\n\n  try {\n    const response = await fetchDynamicConfig(appFields);\n\n    // Note the SDK only clears throttle state if response is success or non-retriable.\n    retryData.deleteThrottleMetadata(appId);\n\n    return response;\n  } catch (e) {\n    if (!isRetriableError(e)) {\n      retryData.deleteThrottleMetadata(appId);\n      if (measurementId) {\n        logger.warn(\n          `Failed to fetch this Firebase app's measurement ID from the server.` +\n            ` Falling back to the measurement ID ${measurementId}` +\n            ` provided in the \"measurementId\" field in the local Firebase config. [${e.message}]`\n        );\n        return { appId, measurementId };\n      } else {\n        throw e;\n      }\n    }\n\n    const backoffMillis =\n      Number(e.customData.httpStatus) === 503\n        ? calculateBackoffMillis(\n            backoffCount,\n            retryData.intervalMillis,\n            LONG_RETRY_FACTOR\n          )\n        : calculateBackoffMillis(backoffCount, retryData.intervalMillis);\n\n    // Increments backoff state.\n    const throttleMetadata = {\n      throttleEndTimeMillis: Date.now() + backoffMillis,\n      backoffCount: backoffCount + 1\n    };\n\n    // Persists state.\n    retryData.setThrottleMetadata(appId, throttleMetadata);\n    logger.debug(`Calling attemptFetch again in ${backoffMillis} millis`);\n\n    return attemptFetchDynamicConfigWithRetry(\n      appFields,\n      throttleMetadata,\n      signal,\n      retryData\n    );\n  }\n}\n\n/**\n * Supports waiting on a backoff by:\n *\n * <ul>\n *   <li>Promisifying setTimeout, so we can set a timeout in our Promise chain</li>\n *   <li>Listening on a signal bus for abort events, just like the Fetch API</li>\n *   <li>Failing in the same way the Fetch API fails, so timing out a live request and a throttled\n *       request appear the same.</li>\n * </ul>\n *\n * <p>Visible for testing.\n */\nfunction setAbortableTimeout(\n  signal: AnalyticsAbortSignal,\n  throttleEndTimeMillis: number\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    // Derives backoff from given end time, normalizing negative numbers to zero.\n    const backoffMillis = Math.max(throttleEndTimeMillis - Date.now(), 0);\n\n    const timeout = setTimeout(resolve, backoffMillis);\n\n    // Adds listener, rather than sets onabort, because signal is a shared object.\n    signal.addEventListener(() => {\n      clearTimeout(timeout);\n      // If the request completes before this timeout, the rejection has no effect.\n      reject(\n        ERROR_FACTORY.create(AnalyticsError.FETCH_THROTTLE, {\n          throttleEndTimeMillis\n        })\n      );\n    });\n  });\n}\n\ntype RetriableError = FirebaseError & { customData: { httpStatus: string } };\n\n/**\n * Returns true if the {@link Error} indicates a fetch request may succeed later.\n */\nfunction isRetriableError(e: Error): e is RetriableError {\n  if (!(e instanceof FirebaseError) || !e.customData) {\n    return false;\n  }\n\n  // Uses string index defined by ErrorData, which FirebaseError implements.\n  const httpStatus = Number(e.customData['httpStatus']);\n\n  return (\n    httpStatus === 429 ||\n    httpStatus === 500 ||\n    httpStatus === 503 ||\n    httpStatus === 504\n  );\n}\n\n/**\n * Shims a minimal AbortSignal (copied from Remote Config).\n *\n * <p>AbortController's AbortSignal conveniently decouples fetch timeout logic from other aspects\n * of networking, such as retries. Firebase doesn't use AbortController enough to justify a\n * polyfill recommendation, like we do with the Fetch API, but this minimal shim can easily be\n * swapped out if/when we do.\n */\nexport class AnalyticsAbortSignal {\n  listeners: Array<() => void> = [];\n  addEventListener(listener: () => void): void {\n    this.listeners.push(listener);\n  }\n  abort(): void {\n    this.listeners.forEach(listener => listener());\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  DynamicConfig,\n  Gtag,\n  MinimalDynamicConfig\n} from '@firebase/analytics-types';\nimport { GtagCommand, GA_FID_KEY, ORIGIN_KEY } from './constants';\nimport { FirebaseInstallations } from '@firebase/installations-types';\nimport { fetchDynamicConfigWithRetry } from './get-config';\nimport { logger } from './logger';\nimport { FirebaseApp } from '@firebase/app-types';\nimport {\n  isIndexedDBAvailable,\n  validateIndexedDBOpenable\n} from '@firebase/util';\nimport { ERROR_FACTORY, AnalyticsError } from './errors';\n\nasync function validateIndexedDB(): Promise<boolean> {\n  if (!isIndexedDBAvailable()) {\n    logger.warn(\n      ERROR_FACTORY.create(AnalyticsError.INDEXEDDB_UNAVAILABLE, {\n        errorInfo: 'IndexedDB is not available in this environment.'\n      }).message\n    );\n    return false;\n  } else {\n    try {\n      await validateIndexedDBOpenable();\n    } catch (e) {\n      logger.warn(\n        ERROR_FACTORY.create(AnalyticsError.INDEXEDDB_UNAVAILABLE, {\n          errorInfo: e\n        }).message\n      );\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Initialize the analytics instance in gtag.js by calling config command with fid.\n *\n * NOTE: We combine analytics initialization and setting fid together because we want fid to be\n * part of the `page_view` event that's sent during the initialization\n * @param app Firebase app\n * @param gtagCore The gtag function that's not wrapped.\n * @param dynamicConfigPromisesList Array of all dynamic config promises.\n * @param measurementIdToAppId Maps measurementID to appID.\n * @param installations FirebaseInstallations instance.\n *\n * @returns Measurement ID.\n */\nexport async function initializeIds(\n  app: FirebaseApp,\n  dynamicConfigPromisesList: Array<\n    Promise<DynamicConfig | MinimalDynamicConfig>\n  >,\n  measurementIdToAppId: { [key: string]: string },\n  installations: FirebaseInstallations,\n  gtagCore: Gtag\n): Promise<string> {\n  const dynamicConfigPromise = fetchDynamicConfigWithRetry(app);\n  // Once fetched, map measurementIds to appId, for ease of lookup in wrapped gtag function.\n  dynamicConfigPromise\n    .then(config => {\n      measurementIdToAppId[config.measurementId] = config.appId;\n      if (\n        app.options.measurementId &&\n        config.measurementId !== app.options.measurementId\n      ) {\n        logger.warn(\n          `The measurement ID in the local Firebase config (${app.options.measurementId})` +\n            ` does not match the measurement ID fetched from the server (${config.measurementId}).` +\n            ` To ensure analytics events are always sent to the correct Analytics property,` +\n            ` update the` +\n            ` measurement ID field in the local config or remove it from the local config.`\n        );\n      }\n    })\n    .catch(e => logger.error(e));\n  // Add to list to track state of all dynamic config promises.\n  dynamicConfigPromisesList.push(dynamicConfigPromise);\n\n  const fidPromise: Promise<string | undefined> = validateIndexedDB().then(\n    envIsValid => {\n      if (envIsValid) {\n        return installations.getId();\n      } else {\n        return undefined;\n      }\n    }\n  );\n\n  const [dynamicConfig, fid] = await Promise.all([\n    dynamicConfigPromise,\n    fidPromise\n  ]);\n\n  // This command initializes gtag.js and only needs to be called once for the entire web app,\n  // but since it is idempotent, we can call it multiple times.\n  // We keep it together with other initialization logic for better code structure.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  gtagCore('js' as any, new Date());\n\n  const configProperties: { [key: string]: string | boolean } = {\n    // guard against developers accidentally setting properties with prefix `firebase_`\n    [ORIGIN_KEY]: 'firebase',\n    update: true\n  };\n\n  if (fid != null) {\n    configProperties[GA_FID_KEY] = fid;\n  }\n\n  // It should be the first config command called on this GA-ID\n  // Initialize this GA-ID and set FID on it using the gtag config API.\n  gtagCore(GtagCommand.CONFIG, dynamicConfig.measurementId, configProperties);\n  return dynamicConfig.measurementId;\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  FirebaseAnalytics,\n  Gtag,\n  SettingsOptions,\n  DynamicConfig,\n  MinimalDynamicConfig\n} from '@firebase/analytics-types';\nimport {\n  logEvent,\n  setCurrentScreen,\n  setUserId,\n  setUserProperties,\n  setAnalyticsCollectionEnabled\n} from './functions';\nimport {\n  insertScriptTag,\n  getOrCreateDataLayer,\n  wrapOrCreateGtag,\n  findGtagScriptOnPage\n} from './helpers';\nimport { AnalyticsError, ERROR_FACTORY } from './errors';\nimport { FirebaseApp } from '@firebase/app-types';\nimport { FirebaseInstallations } from '@firebase/installations-types';\nimport { areCookiesEnabled, isBrowserExtension } from '@firebase/util';\nimport { initializeIds } from './initialize-ids';\nimport { logger } from './logger';\nimport { FirebaseService } from '@firebase/app-types/private';\n\ninterface FirebaseAnalyticsInternal\n  extends FirebaseAnalytics,\n    FirebaseService {}\n\n/**\n * Maps appId to full initialization promise. Wrapped gtag calls must wait on\n * all or some of these, depending on the call's `send_to` param and the status\n * of the dynamic config fetches (see below).\n */\nlet initializationPromisesMap: {\n  [appId: string]: Promise<string>; // Promise contains measurement ID string.\n} = {};\n\n/**\n * List of dynamic config fetch promises. In certain cases, wrapped gtag calls\n * wait on all these to be complete in order to determine if it can selectively\n * wait for only certain initialization (FID) promises or if it must wait for all.\n */\nlet dynamicConfigPromisesList: Array<Promise<\n  DynamicConfig | MinimalDynamicConfig\n>> = [];\n\n/**\n * Maps fetched measurementIds to appId. Populated when the app's dynamic config\n * fetch completes. If already populated, gtag config calls can use this to\n * selectively wait for only this app's initialization promise (FID) instead of all\n * initialization promises.\n */\nconst measurementIdToAppId: { [measurementId: string]: string } = {};\n\n/**\n * Name for window global data layer array used by GA: defaults to 'dataLayer'.\n */\nlet dataLayerName: string = 'dataLayer';\n\n/**\n * Name for window global gtag function used by GA: defaults to 'gtag'.\n */\nlet gtagName: string = 'gtag';\n\n/**\n * Reproduction of standard gtag function or reference to existing\n * gtag function on window object.\n */\nlet gtagCoreFunction: Gtag;\n\n/**\n * Wrapper around gtag function that ensures FID is sent with all\n * relevant event and config calls.\n */\nlet wrappedGtagFunction: Gtag;\n\n/**\n * Flag to ensure page initialization steps (creation or wrapping of\n * dataLayer and gtag script) are only run once per page load.\n */\nlet globalInitDone: boolean = false;\n\n/**\n * For testing\n */\nexport function resetGlobalVars(\n  newGlobalInitDone = false,\n  newInitializationPromisesMap = {},\n  newDynamicPromises = []\n): void {\n  globalInitDone = newGlobalInitDone;\n  initializationPromisesMap = newInitializationPromisesMap;\n  dynamicConfigPromisesList = newDynamicPromises;\n  dataLayerName = 'dataLayer';\n  gtagName = 'gtag';\n}\n\n/**\n * For testing\n */\nexport function getGlobalVars(): {\n  initializationPromisesMap: { [appId: string]: Promise<string> };\n  dynamicConfigPromisesList: Array<\n    Promise<DynamicConfig | MinimalDynamicConfig>\n  >;\n} {\n  return {\n    initializationPromisesMap,\n    dynamicConfigPromisesList\n  };\n}\n\n/**\n * This must be run before calling firebase.analytics() or it won't\n * have any effect.\n * @param options Custom gtag and dataLayer names.\n */\nexport function settings(options: SettingsOptions): void {\n  if (globalInitDone) {\n    throw ERROR_FACTORY.create(AnalyticsError.ALREADY_INITIALIZED);\n  }\n  if (options.dataLayerName) {\n    dataLayerName = options.dataLayerName;\n  }\n  if (options.gtagName) {\n    gtagName = options.gtagName;\n  }\n}\n\n/**\n * Returns true if no environment mismatch is found.\n * If environment mismatches are found, throws an INVALID_ANALYTICS_CONTEXT\n * error that also lists details for each mismatch found.\n */\nfunction warnOnBrowserContextMismatch(): void {\n  const mismatchedEnvMessages = [];\n  if (isBrowserExtension()) {\n    mismatchedEnvMessages.push('This is a browser extension environment.');\n  }\n  if (!areCookiesEnabled()) {\n    mismatchedEnvMessages.push('Cookies are not available.');\n  }\n  if (mismatchedEnvMessages.length > 0) {\n    const details = mismatchedEnvMessages\n      .map((message, index) => `(${index + 1}) ${message}`)\n      .join(' ');\n    const err = ERROR_FACTORY.create(AnalyticsError.INVALID_ANALYTICS_CONTEXT, {\n      errorInfo: details\n    });\n    logger.warn(err.message);\n  }\n}\n\nexport function factory(\n  app: FirebaseApp,\n  installations: FirebaseInstallations\n): FirebaseAnalytics {\n  warnOnBrowserContextMismatch();\n  const appId = app.options.appId;\n  if (!appId) {\n    throw ERROR_FACTORY.create(AnalyticsError.NO_APP_ID);\n  }\n  if (!app.options.apiKey) {\n    if (app.options.measurementId) {\n      logger.warn(\n        `The \"apiKey\" field is empty in the local Firebase config. This is needed to fetch the latest` +\n          ` measurement ID for this Firebase app. Falling back to the measurement ID ${app.options.measurementId}` +\n          ` provided in the \"measurementId\" field in the local Firebase config.`\n      );\n    } else {\n      throw ERROR_FACTORY.create(AnalyticsError.NO_API_KEY);\n    }\n  }\n  if (initializationPromisesMap[appId] != null) {\n    throw ERROR_FACTORY.create(AnalyticsError.ALREADY_EXISTS, {\n      id: appId\n    });\n  }\n\n  if (!globalInitDone) {\n    // Steps here should only be done once per page: creation or wrapping\n    // of dataLayer and global gtag function.\n\n    // Detect if user has already put the gtag <script> tag on this page.\n    if (!findGtagScriptOnPage()) {\n      insertScriptTag(dataLayerName);\n    }\n    getOrCreateDataLayer(dataLayerName);\n\n    const { wrappedGtag, gtagCore } = wrapOrCreateGtag(\n      initializationPromisesMap,\n      dynamicConfigPromisesList,\n      measurementIdToAppId,\n      dataLayerName,\n      gtagName\n    );\n    wrappedGtagFunction = wrappedGtag;\n    gtagCoreFunction = gtagCore;\n\n    globalInitDone = true;\n  }\n  // Async but non-blocking.\n  // This map reflects the completion state of all promises for each appId.\n  initializationPromisesMap[appId] = initializeIds(\n    app,\n    dynamicConfigPromisesList,\n    measurementIdToAppId,\n    installations,\n    gtagCoreFunction\n  );\n\n  const analyticsInstance: FirebaseAnalyticsInternal = {\n    app,\n    // Public methods return void for API simplicity and to better match gtag,\n    // while internal implementations return promises.\n    logEvent: (eventName, eventParams, options) => {\n      logEvent(\n        wrappedGtagFunction,\n        initializationPromisesMap[appId],\n        eventName,\n        eventParams,\n        options\n      ).catch(e => logger.error(e));\n    },\n    setCurrentScreen: (screenName, options) => {\n      setCurrentScreen(\n        wrappedGtagFunction,\n        initializationPromisesMap[appId],\n        screenName,\n        options\n      ).catch(e => logger.error(e));\n    },\n    setUserId: (id, options) => {\n      setUserId(\n        wrappedGtagFunction,\n        initializationPromisesMap[appId],\n        id,\n        options\n      ).catch(e => logger.error(e));\n    },\n    setUserProperties: (properties, options) => {\n      setUserProperties(\n        wrappedGtagFunction,\n        initializationPromisesMap[appId],\n        properties,\n        options\n      ).catch(e => logger.error(e));\n    },\n    setAnalyticsCollectionEnabled: enabled => {\n      setAnalyticsCollectionEnabled(\n        initializationPromisesMap[appId],\n        enabled\n      ).catch(e => logger.error(e));\n    },\n    INTERNAL: {\n      delete: (): Promise<void> => {\n        delete initializationPromisesMap[appId];\n        return Promise.resolve();\n      }\n    }\n  };\n\n  return analyticsInstance;\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  AnalyticsCallOptions,\n  Gtag,\n  CustomParams,\n  ControlParams,\n  EventParams\n} from '@firebase/analytics-types';\nimport { GtagCommand } from './constants';\n/**\n * Logs an analytics event through the Firebase SDK.\n *\n * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event\n * @param eventName Google Analytics event name, choose from standard list or use a custom string.\n * @param eventParams Analytics event parameters.\n */\nexport async function logEvent(\n  gtagFunction: Gtag,\n  initializationPromise: Promise<string>,\n  eventName: string,\n  eventParams?: EventParams,\n  options?: AnalyticsCallOptions\n): Promise<void> {\n  if (options && options.global) {\n    gtagFunction(GtagCommand.EVENT, eventName, eventParams);\n    return;\n  } else {\n    const measurementId = await initializationPromise;\n    const params: EventParams | ControlParams = {\n      ...eventParams,\n      'send_to': measurementId\n    };\n    gtagFunction(GtagCommand.EVENT, eventName, params);\n  }\n}\n\n/**\n * Set screen_name parameter for this Google Analytics ID.\n *\n * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event\n * @param screenName Screen name string to set.\n */\nexport async function setCurrentScreen(\n  gtagFunction: Gtag,\n  initializationPromise: Promise<string>,\n  screenName: string | null,\n  options?: AnalyticsCallOptions\n): Promise<void> {\n  if (options && options.global) {\n    gtagFunction(GtagCommand.SET, { 'screen_name': screenName });\n    return Promise.resolve();\n  } else {\n    const measurementId = await initializationPromise;\n    gtagFunction(GtagCommand.CONFIG, measurementId, {\n      update: true,\n      'screen_name': screenName\n    });\n  }\n}\n\n/**\n * Set user_id parameter for this Google Analytics ID.\n *\n * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event\n * @param id User ID string to set\n */\nexport async function setUserId(\n  gtagFunction: Gtag,\n  initializationPromise: Promise<string>,\n  id: string | null,\n  options?: AnalyticsCallOptions\n): Promise<void> {\n  if (options && options.global) {\n    gtagFunction(GtagCommand.SET, { 'user_id': id });\n    return Promise.resolve();\n  } else {\n    const measurementId = await initializationPromise;\n    gtagFunction(GtagCommand.CONFIG, measurementId, {\n      update: true,\n      'user_id': id\n    });\n  }\n}\n\n/**\n * Set all other user properties other than user_id and screen_name.\n *\n * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event\n * @param properties Map of user properties to set\n */\nexport async function setUserProperties(\n  gtagFunction: Gtag,\n  initializationPromise: Promise<string>,\n  properties: CustomParams,\n  options?: AnalyticsCallOptions\n): Promise<void> {\n  if (options && options.global) {\n    const flatProperties: { [key: string]: unknown } = {};\n    for (const key of Object.keys(properties)) {\n      // use dot notation for merge behavior in gtag.js\n      flatProperties[`user_properties.${key}`] = properties[key];\n    }\n    gtagFunction(GtagCommand.SET, flatProperties);\n    return Promise.resolve();\n  } else {\n    const measurementId = await initializationPromise;\n    gtagFunction(GtagCommand.CONFIG, measurementId, {\n      update: true,\n      'user_properties': properties\n    });\n  }\n}\n\n/**\n * Set whether collection is enabled for this ID.\n *\n * @param enabled If true, collection is enabled for this ID.\n */\nexport async function setAnalyticsCollectionEnabled(\n  initializationPromise: Promise<string>,\n  enabled: boolean\n): Promise<void> {\n  const measurementId = await initializationPromise;\n  window[`ga-disable-${measurementId}`] = !enabled;\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 { FirebaseNamespace } from '@firebase/app-types';\nimport { firebase as firebaseNamespace } from './src/firebaseNamespace';\nimport { isNode, isBrowser } from '@firebase/util';\nimport { logger } from './src/logger';\nimport { registerCoreComponents } from './src/registerCoreComponents';\n\n// Firebase Lite detection test\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nif (isBrowser() && (self as any).firebase !== undefined) {\n  logger.warn(`\n    Warning: Firebase is already defined in the global scope. Please make sure\n    Firebase library is only loaded once.\n  `);\n\n  // eslint-disable-next-line\n  const sdkVersion = ((self as any).firebase as FirebaseNamespace).SDK_VERSION;\n  if (sdkVersion && sdkVersion.indexOf('LITE') >= 0) {\n    logger.warn(`\n    Warning: You are trying to load Firebase while using Firebase Performance standalone script.\n    You should load Firebase Performance with this instance of Firebase to avoid loading duplicate code.\n    `);\n  }\n}\n\nconst initializeApp = firebaseNamespace.initializeApp;\n\n// TODO: This disable can be removed and the 'ignoreRestArgs' option added to\n// the no-explicit-any rule when ESlint releases it.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfirebaseNamespace.initializeApp = function (...args: any) {\n  // Environment check before initializing app\n  // Do the check in initializeApp, so people have a chance to disable it by setting logLevel\n  // in @firebase/logger\n  if (isNode()) {\n    logger.warn(`\n      Warning: This is a browser-targeted Firebase bundle but it appears it is being\n      run in a Node environment.  If running in a Node environment, make sure you\n      are using the bundle specified by the \"main\" field in package.json.\n      \n      If you are using Webpack, you can specify \"main\" as the first item in\n      \"resolve.mainFields\":\n      https://webpack.js.org/configuration/resolve/#resolvemainfields\n      \n      If using Rollup, use the @rollup/plugin-node-resolve plugin and specify \"main\"\n      as the first item in \"mainFields\", e.g. ['main', 'module'].\n      https://github.com/rollup/@rollup/plugin-node-resolve\n      `);\n  }\n  return initializeApp.apply(undefined, args);\n};\n\nexport const firebase = firebaseNamespace;\n\nregisterCoreComponents(firebase);\n\n// eslint-disable-next-line import/no-default-export\nexport default firebase;\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppConfig\n} from '@firebase/app-types';\nimport {\n  _FirebaseApp,\n  _FirebaseNamespace,\n  FirebaseService\n} from '@firebase/app-types/private';\nimport { deepCopy } from '@firebase/util';\nimport {\n  ComponentContainer,\n  Component,\n  ComponentType,\n  Name\n} from '@firebase/component';\nimport { AppError, ERROR_FACTORY } from './errors';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport { logger } from './logger';\n\n/**\n * Global context object for a collection of services using\n * a shared authentication state.\n */\nexport class FirebaseAppImpl implements FirebaseApp {\n  private readonly options_: FirebaseOptions;\n  private readonly name_: string;\n  private isDeleted_ = false;\n  private automaticDataCollectionEnabled_: boolean;\n  private container: ComponentContainer;\n\n  constructor(\n    options: FirebaseOptions,\n    config: FirebaseAppConfig,\n    private readonly firebase_: _FirebaseNamespace\n  ) {\n    this.name_ = config.name!;\n    this.automaticDataCollectionEnabled_ =\n      config.automaticDataCollectionEnabled || false;\n    this.options_ = deepCopy<FirebaseOptions>(options);\n    this.container = new ComponentContainer(config.name!);\n\n    // add itself to container\n    this._addComponent(new Component('app', () => this, ComponentType.PUBLIC));\n    // populate ComponentContainer with existing components\n    for (const component of this.firebase_.INTERNAL.components.values()) {\n      this._addComponent(component);\n    }\n  }\n\n  get automaticDataCollectionEnabled(): boolean {\n    this.checkDestroyed_();\n    return this.automaticDataCollectionEnabled_;\n  }\n\n  set automaticDataCollectionEnabled(val) {\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  delete(): Promise<void> {\n    return new Promise(resolve => {\n      this.checkDestroyed_();\n      resolve();\n    })\n      .then(() => {\n        this.firebase_.INTERNAL.removeApp(this.name_);\n\n        return Promise.all(\n          this.container.getProviders().map(provider => provider.delete())\n        );\n      })\n      .then((): void => {\n        this.isDeleted_ = true;\n      });\n  }\n\n  /**\n   * Return a service instance associated with this app (creating it\n   * on demand), identified by the passed instanceIdentifier.\n   *\n   * NOTE: Currently storage and functions are the only ones that are leveraging this\n   * functionality. They invoke it by calling:\n   *\n   * ```javascript\n   * firebase.app().storage('STORAGE BUCKET ID')\n   * ```\n   *\n   * The service name is passed to this already\n   * @internal\n   */\n  _getService(\n    name: string,\n    instanceIdentifier: string = DEFAULT_ENTRY_NAME\n  ): FirebaseService {\n    this.checkDestroyed_();\n\n    // getImmediate will always succeed because _getService is only called for registered components.\n    return (this.container.getProvider(name as Name).getImmediate({\n      identifier: instanceIdentifier\n    }) as unknown) as FirebaseService;\n  }\n  /**\n   * Remove a service instance from the cache, so we will create a new instance for this service\n   * when people try to get this service again.\n   *\n   * NOTE: currently only firestore is using this functionality to support firestore shutdown.\n   *\n   * @param name The service name\n   * @param instanceIdentifier instance identifier in case multiple instances are allowed\n   * @internal\n   */\n  _removeServiceInstance(\n    name: string,\n    instanceIdentifier: string = DEFAULT_ENTRY_NAME\n  ): void {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    this.container.getProvider(name as any).clearInstance(instanceIdentifier);\n  }\n\n  /**\n   * @param component the component being added to this app's container\n   */\n  _addComponent(component: Component): void {\n    try {\n      this.container.addComponent(component);\n    } catch (e) {\n      logger.debug(\n        `Component ${component.name} failed to register with FirebaseApp ${this.name}`,\n        e\n      );\n    }\n  }\n\n  _addOrOverwriteComponent(component: Component): void {\n    this.container.addOrOverwriteComponent(component);\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  private checkDestroyed_(): void {\n    if (this.isDeleted_) {\n      throw ERROR_FACTORY.create(AppError.APP_DELETED, { appName: this.name_ });\n    }\n  }\n}\n\n// Prevent dead-code elimination of these methods w/o invalid property\n// copying.\n(FirebaseAppImpl.prototype.name && FirebaseAppImpl.prototype.options) ||\n  FirebaseAppImpl.prototype.delete ||\n  console.log('dc');\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 { FirebaseNamespace } from '@firebase/app-types';\nimport { _FirebaseApp, _FirebaseNamespace } from '@firebase/app-types/private';\nimport { createSubscribe, deepExtend, ErrorFactory } from '@firebase/util';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { createFirebaseNamespaceCore } from './firebaseNamespaceCore';\n\n/**\n * Return a firebase namespace object.\n *\n * In production, this will be called exactly once and the result\n * assigned to the 'firebase' global.  It may be called multiple times\n * in unit tests.\n */\nexport function createFirebaseNamespace(): FirebaseNamespace {\n  const namespace = createFirebaseNamespaceCore(FirebaseAppImpl);\n  (namespace as _FirebaseNamespace).INTERNAL = {\n    ...(namespace as _FirebaseNamespace).INTERNAL,\n    createFirebaseNamespace,\n    extendNamespace,\n    createSubscribe,\n    ErrorFactory,\n    deepExtend\n  };\n\n  /**\n   * Patch the top-level firebase namespace with additional properties.\n   *\n   * firebase.INTERNAL.extendNamespace()\n   */\n  function extendNamespace(props: { [prop: string]: unknown }): void {\n    deepExtend(namespace, props);\n  }\n\n  return namespace;\n}\n\nexport const firebase = createFirebaseNamespace();\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  FirebaseNamespace,\n  FirebaseAppConfig\n} from '@firebase/app-types';\nimport {\n  _FirebaseApp,\n  _FirebaseNamespace,\n  FirebaseService,\n  FirebaseServiceNamespace\n} from '@firebase/app-types/private';\nimport { deepExtend, contains } from '@firebase/util';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport { FirebaseAppLiteImpl } from './lite/firebaseAppLite';\nimport { DEFAULT_ENTRY_NAME, PLATFORM_LOG_STRING } from './constants';\nimport { version } from '../../firebase/package.json';\nimport { logger } from './logger';\nimport {\n  setUserLogHandler,\n  setLogLevel,\n  LogCallback,\n  LogOptions\n} from '@firebase/logger';\nimport { Component, ComponentType, Name } from '@firebase/component';\n\n/**\n * Because auth can't share code with other components, we attach the utility functions\n * in an internal namespace to share code.\n * This function return a firebase namespace object without\n * any utility functions, so it can be shared between the regular firebaseNamespace and\n * the lite version.\n */\nexport function createFirebaseNamespaceCore(\n  firebaseAppImpl: typeof FirebaseAppImpl | typeof FirebaseAppLiteImpl\n): FirebaseNamespace {\n  const apps: { [name: string]: FirebaseApp } = {};\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const components = new Map<string, Component<any>>();\n\n  // A namespace is a plain JavaScript Object.\n  const namespace: FirebaseNamespace = {\n    // Hack to prevent Babel from modifying the object returned\n    // as the firebase namespace.\n    // @ts-ignore\n    __esModule: true,\n    initializeApp,\n    // @ts-ignore\n    app,\n    registerVersion,\n    setLogLevel,\n    onLog,\n    // @ts-ignore\n    apps: null,\n    SDK_VERSION: version,\n    INTERNAL: {\n      registerComponent,\n      removeApp,\n      components,\n      useAsService\n    }\n  };\n\n  // Inject a circular default export to allow Babel users who were previously\n  // using:\n  //\n  //   import firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase').default;\n  //\n  // instead of\n  //\n  //   import * as firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase');\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (namespace as any)['default'] = namespace;\n\n  // firebase.apps is a read-only getter.\n  Object.defineProperty(namespace, 'apps', {\n    get: getApps\n  });\n\n  /**\n   * Called by App.delete() - but before any services associated with the App\n   * are deleted.\n   */\n  function removeApp(name: string): void {\n    delete apps[name];\n  }\n\n  /**\n   * Get the App object for a given name (or DEFAULT).\n   */\n  function app(name?: string): FirebaseApp {\n    name = name || DEFAULT_ENTRY_NAME;\n    if (!contains(apps, name)) {\n      throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n    }\n    return apps[name];\n  }\n\n  // @ts-ignore\n  app['App'] = firebaseAppImpl;\n  /**\n   * Create a new App instance (name must be unique).\n   */\n  function initializeApp(\n    options: FirebaseOptions,\n    config?: FirebaseAppConfig\n  ): FirebaseApp;\n  function initializeApp(options: FirebaseOptions, name?: string): FirebaseApp;\n  function initializeApp(\n    options: FirebaseOptions,\n    rawConfig = {}\n  ): FirebaseApp {\n    if (typeof rawConfig !== 'object' || rawConfig === null) {\n      const name = rawConfig;\n      rawConfig = { name };\n    }\n\n    const config = rawConfig as FirebaseAppConfig;\n\n    if (config.name === undefined) {\n      config.name = DEFAULT_ENTRY_NAME;\n    }\n\n    const { name } = config;\n\n    if (typeof name !== 'string' || !name) {\n      throw ERROR_FACTORY.create(AppError.BAD_APP_NAME, {\n        appName: String(name)\n      });\n    }\n\n    if (contains(apps, name)) {\n      throw ERROR_FACTORY.create(AppError.DUPLICATE_APP, { appName: name });\n    }\n\n    const app = new firebaseAppImpl(\n      options,\n      config,\n      namespace as _FirebaseNamespace\n    );\n\n    apps[name] = app;\n\n    return app;\n  }\n\n  /*\n   * Return an array of all the non-deleted FirebaseApps.\n   */\n  function getApps(): FirebaseApp[] {\n    // Make a copy so caller cannot mutate the apps list.\n    return Object.keys(apps).map(name => apps[name]);\n  }\n\n  function registerComponent(\n    component: Component\n  ): FirebaseServiceNamespace<FirebaseService> | null {\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 component.type === ComponentType.PUBLIC\n        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (namespace as any)[componentName]\n        : null;\n    }\n\n    components.set(componentName, component);\n\n    // create service namespace for public components\n    if (component.type === ComponentType.PUBLIC) {\n      // The Service namespace is an accessor function ...\n      const serviceNamespace = (\n        appArg: FirebaseApp = app()\n      ): FirebaseService => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (typeof (appArg as any)[componentName] !== 'function') {\n          // Invalid argument.\n          // This happens in the following case: firebase.storage('gs:/')\n          throw ERROR_FACTORY.create(AppError.INVALID_APP_ARGUMENT, {\n            appName: componentName\n          });\n        }\n\n        // Forward service instance lookup to the FirebaseApp.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return (appArg as any)[componentName]();\n      };\n\n      // ... and a container for service-level properties.\n      if (component.serviceProps !== undefined) {\n        deepExtend(serviceNamespace, component.serviceProps);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (namespace as any)[componentName] = serviceNamespace;\n\n      // Patch the FirebaseAppImpl prototype\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (firebaseAppImpl.prototype as any)[componentName] =\n        // TODO: The eslint disable can be removed and the 'ignoreRestArgs'\n        // option added to the no-explicit-any rule when ESlint releases it.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        function (...args: any) {\n          const serviceFxn = this._getService.bind(this, componentName);\n          return serviceFxn.apply(\n            this,\n            component.multipleInstances ? args : []\n          );\n        };\n    }\n\n    // add the component to existing app instances\n    for (const appName of Object.keys(apps)) {\n      (apps[appName] as _FirebaseApp)._addComponent(component);\n    }\n\n    return component.type === ComponentType.PUBLIC\n      ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (namespace as any)[componentName]\n      : null;\n  }\n\n  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  function onLog(logCallback: LogCallback | null, options?: LogOptions): void {\n    if (logCallback !== null && typeof logCallback !== 'function') {\n      throw ERROR_FACTORY.create(AppError.INVALID_LOG_ARGUMENT, {\n        appName: name\n      });\n    }\n    setUserLogHandler(logCallback, options);\n  }\n\n  // Map the requested service to a registered service name\n  // (used to map auth to serverAuth service when needed).\n  function useAsService(app: FirebaseApp, name: string): string | null {\n    if (name === 'serverAuth') {\n      return null;\n    }\n\n    const useService = name;\n\n    return useService;\n  }\n\n  return namespace;\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';\n\nexport class 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();\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(\n  provider: Provider<Name>\n): provider is Provider<'app-version'> {\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 { FirebaseNamespace } from '@firebase/app-types';\nimport { _FirebaseNamespace } from '@firebase/app-types/private';\nimport { Component, ComponentType } from '@firebase/component';\nimport { PlatformLoggerService } from './platformLoggerService';\nimport { name, version } from '../package.json';\n\nexport function registerCoreComponents(\n  firebase: FirebaseNamespace,\n  variant?: string\n): void {\n  (firebase as _FirebaseNamespace).INTERNAL.registerComponent(\n    new Component(\n      'platform-logger',\n      container => new PlatformLoggerService(container),\n      ComponentType.PRIVATE\n    )\n  );\n  // Register `app` package.\n  firebase.registerVersion(name, version, variant);\n  // Register platform SDK identifier (no version).\n  firebase.registerVersion('fire-js', '');\n}\n","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","/* eslint-disable */\n// Inspired by https://github.com/garycourt/murmurhash-js\n// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86\nfunction murmur2(str) {\n  // 'm' and 'r' are mixing constants generated offline.\n  // They're not really 'magic', they just happen to work well.\n  // const m = 0x5bd1e995;\n  // const r = 24;\n  // Initialize the hash\n  var h = 0; // Mix 4 bytes at a time into the hash\n\n  var k,\n      i = 0,\n      len = str.length;\n\n  for (; len >= 4; ++i, len -= 4) {\n    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;\n    k =\n    /* Math.imul(k, m): */\n    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);\n    k ^=\n    /* k >>> r: */\n    k >>> 24;\n    h =\n    /* Math.imul(k, m): */\n    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^\n    /* Math.imul(h, m): */\n    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);\n  } // Handle the last few bytes of the input array\n\n\n  switch (len) {\n    case 3:\n      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;\n\n    case 2:\n      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;\n\n    case 1:\n      h ^= str.charCodeAt(i) & 0xff;\n      h =\n      /* Math.imul(h, m): */\n      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);\n  } // Do a few final mixes of the hash to ensure the last few\n  // bytes are well-incorporated.\n\n\n  h ^= h >>> 13;\n  h =\n  /* Math.imul(h, m): */\n  (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);\n  return ((h ^ h >>> 15) >>> 0).toString(36);\n}\n\nexport default murmur2;\n","import hashString from '@emotion/hash';\nimport unitless from '@emotion/unitless';\nimport memoize from '@emotion/memoize';\n\nvar ILLEGAL_ESCAPE_SEQUENCE_ERROR = \"You have illegal escape sequence in your template literal, most likely inside content's property value.\\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \\\"content: '\\\\00d7';\\\" should become \\\"content: '\\\\\\\\00d7';\\\".\\nYou can read more about this here:\\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences\";\nvar UNDEFINED_AS_OBJECT_KEY_ERROR = \"You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).\";\nvar hyphenateRegex = /[A-Z]|^ms/g;\nvar animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;\n\nvar isCustomProperty = function isCustomProperty(property) {\n  return property.charCodeAt(1) === 45;\n};\n\nvar isProcessableValue = function isProcessableValue(value) {\n  return value != null && typeof value !== 'boolean';\n};\n\nvar processStyleName = memoize(function (styleName) {\n  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();\n});\n\nvar processStyleValue = function processStyleValue(key, value) {\n  switch (key) {\n    case 'animation':\n    case 'animationName':\n      {\n        if (typeof value === 'string') {\n          return value.replace(animationRegex, function (match, p1, p2) {\n            cursor = {\n              name: p1,\n              styles: p2,\n              next: cursor\n            };\n            return p1;\n          });\n        }\n      }\n  }\n\n  if (unitless[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {\n    return value + 'px';\n  }\n\n  return value;\n};\n\nif (process.env.NODE_ENV !== 'production') {\n  var contentValuePattern = /(attr|calc|counters?|url)\\(/;\n  var contentValues = ['normal', 'none', 'counter', 'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote', 'initial', 'inherit', 'unset'];\n  var oldProcessStyleValue = processStyleValue;\n  var msPattern = /^-ms-/;\n  var hyphenPattern = /-(.)/g;\n  var hyphenatedCache = {};\n\n  processStyleValue = function processStyleValue(key, value) {\n    if (key === 'content') {\n      if (typeof value !== 'string' || contentValues.indexOf(value) === -1 && !contentValuePattern.test(value) && (value.charAt(0) !== value.charAt(value.length - 1) || value.charAt(0) !== '\"' && value.charAt(0) !== \"'\")) {\n        console.error(\"You seem to be using a value for 'content' without quotes, try replacing it with `content: '\\\"\" + value + \"\\\"'`\");\n      }\n    }\n\n    var processed = oldProcessStyleValue(key, value);\n\n    if (processed !== '' && !isCustomProperty(key) && key.indexOf('-') !== -1 && hyphenatedCache[key] === undefined) {\n      hyphenatedCache[key] = true;\n      console.error(\"Using kebab-case for css properties in objects is not supported. Did you mean \" + key.replace(msPattern, 'ms-').replace(hyphenPattern, function (str, _char) {\n        return _char.toUpperCase();\n      }) + \"?\");\n    }\n\n    return processed;\n  };\n}\n\nvar shouldWarnAboutInterpolatingClassNameFromCss = true;\n\nfunction handleInterpolation(mergedProps, registered, interpolation, couldBeSelectorInterpolation) {\n  if (interpolation == null) {\n    return '';\n  }\n\n  if (interpolation.__emotion_styles !== undefined) {\n    if (process.env.NODE_ENV !== 'production' && interpolation.toString() === 'NO_COMPONENT_SELECTOR') {\n      throw new Error('Component selectors can only be used in conjunction with babel-plugin-emotion.');\n    }\n\n    return interpolation;\n  }\n\n  switch (typeof interpolation) {\n    case 'boolean':\n      {\n        return '';\n      }\n\n    case 'object':\n      {\n        if (interpolation.anim === 1) {\n          cursor = {\n            name: interpolation.name,\n            styles: interpolation.styles,\n            next: cursor\n          };\n          return interpolation.name;\n        }\n\n        if (interpolation.styles !== undefined) {\n          var next = interpolation.next;\n\n          if (next !== undefined) {\n            // not the most efficient thing ever but this is a pretty rare case\n            // and there will be very few iterations of this generally\n            while (next !== undefined) {\n              cursor = {\n                name: next.name,\n                styles: next.styles,\n                next: cursor\n              };\n              next = next.next;\n            }\n          }\n\n          var styles = interpolation.styles + \";\";\n\n          if (process.env.NODE_ENV !== 'production' && interpolation.map !== undefined) {\n            styles += interpolation.map;\n          }\n\n          return styles;\n        }\n\n        return createStringFromObject(mergedProps, registered, interpolation);\n      }\n\n    case 'function':\n      {\n        if (mergedProps !== undefined) {\n          var previousCursor = cursor;\n          var result = interpolation(mergedProps);\n          cursor = previousCursor;\n          return handleInterpolation(mergedProps, registered, result, couldBeSelectorInterpolation);\n        } else if (process.env.NODE_ENV !== 'production') {\n          console.error('Functions that are interpolated in css calls will be stringified.\\n' + 'If you want to have a css call based on props, create a function that returns a css call like this\\n' + 'let dynamicStyle = (props) => css`color: ${props.color}`\\n' + 'It can be called directly with props or interpolated in a styled call like this\\n' + \"let SomeComponent = styled('div')`${dynamicStyle}`\");\n        }\n\n        break;\n      }\n\n    case 'string':\n      if (process.env.NODE_ENV !== 'production') {\n        var matched = [];\n        var replaced = interpolation.replace(animationRegex, function (match, p1, p2) {\n          var fakeVarName = \"animation\" + matched.length;\n          matched.push(\"const \" + fakeVarName + \" = keyframes`\" + p2.replace(/^@keyframes animation-\\w+/, '') + \"`\");\n          return \"${\" + fakeVarName + \"}\";\n        });\n\n        if (matched.length) {\n          console.error('`keyframes` output got interpolated into plain string, please wrap it with `css`.\\n\\n' + 'Instead of doing this:\\n\\n' + [].concat(matched, [\"`\" + replaced + \"`\"]).join('\\n') + '\\n\\nYou should wrap it with `css` like this:\\n\\n' + (\"css`\" + replaced + \"`\"));\n        }\n      }\n\n      break;\n  } // finalize string values (regular strings and functions interpolated into css calls)\n\n\n  if (registered == null) {\n    return interpolation;\n  }\n\n  var cached = registered[interpolation];\n\n  if (process.env.NODE_ENV !== 'production' && couldBeSelectorInterpolation && shouldWarnAboutInterpolatingClassNameFromCss && cached !== undefined) {\n    console.error('Interpolating a className from css`` is not recommended and will cause problems with composition.\\n' + 'Interpolating a className from css`` will be completely unsupported in a future major version of Emotion');\n    shouldWarnAboutInterpolatingClassNameFromCss = false;\n  }\n\n  return cached !== undefined && !couldBeSelectorInterpolation ? cached : interpolation;\n}\n\nfunction createStringFromObject(mergedProps, registered, obj) {\n  var string = '';\n\n  if (Array.isArray(obj)) {\n    for (var i = 0; i < obj.length; i++) {\n      string += handleInterpolation(mergedProps, registered, obj[i], false);\n    }\n  } else {\n    for (var _key in obj) {\n      var value = obj[_key];\n\n      if (typeof value !== 'object') {\n        if (registered != null && registered[value] !== undefined) {\n          string += _key + \"{\" + registered[value] + \"}\";\n        } else if (isProcessableValue(value)) {\n          string += processStyleName(_key) + \":\" + processStyleValue(_key, value) + \";\";\n        }\n      } else {\n        if (_key === 'NO_COMPONENT_SELECTOR' && process.env.NODE_ENV !== 'production') {\n          throw new Error('Component selectors can only be used in conjunction with babel-plugin-emotion.');\n        }\n\n        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {\n          for (var _i = 0; _i < value.length; _i++) {\n            if (isProcessableValue(value[_i])) {\n              string += processStyleName(_key) + \":\" + processStyleValue(_key, value[_i]) + \";\";\n            }\n          }\n        } else {\n          var interpolated = handleInterpolation(mergedProps, registered, value, false);\n\n          switch (_key) {\n            case 'animation':\n            case 'animationName':\n              {\n                string += processStyleName(_key) + \":\" + interpolated + \";\";\n                break;\n              }\n\n            default:\n              {\n                if (process.env.NODE_ENV !== 'production' && _key === 'undefined') {\n                  console.error(UNDEFINED_AS_OBJECT_KEY_ERROR);\n                }\n\n                string += _key + \"{\" + interpolated + \"}\";\n              }\n          }\n        }\n      }\n    }\n  }\n\n  return string;\n}\n\nvar labelPattern = /label:\\s*([^\\s;\\n{]+)\\s*;/g;\nvar sourceMapPattern;\n\nif (process.env.NODE_ENV !== 'production') {\n  sourceMapPattern = /\\/\\*#\\ssourceMappingURL=data:application\\/json;\\S+\\s+\\*\\//;\n} // this is the cursor for keyframes\n// keyframes are stored on the SerializedStyles object as a linked list\n\n\nvar cursor;\nvar serializeStyles = function serializeStyles(args, registered, mergedProps) {\n  if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {\n    return args[0];\n  }\n\n  var stringMode = true;\n  var styles = '';\n  cursor = undefined;\n  var strings = args[0];\n\n  if (strings == null || strings.raw === undefined) {\n    stringMode = false;\n    styles += handleInterpolation(mergedProps, registered, strings, false);\n  } else {\n    if (process.env.NODE_ENV !== 'production' && strings[0] === undefined) {\n      console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);\n    }\n\n    styles += strings[0];\n  } // we start at 1 since we've already handled the first arg\n\n\n  for (var i = 1; i < args.length; i++) {\n    styles += handleInterpolation(mergedProps, registered, args[i], styles.charCodeAt(styles.length - 1) === 46);\n\n    if (stringMode) {\n      if (process.env.NODE_ENV !== 'production' && strings[i] === undefined) {\n        console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);\n      }\n\n      styles += strings[i];\n    }\n  }\n\n  var sourceMap;\n\n  if (process.env.NODE_ENV !== 'production') {\n    styles = styles.replace(sourceMapPattern, function (match) {\n      sourceMap = match;\n      return '';\n    });\n  } // using a global regex with .exec is stateful so lastIndex has to be reset each time\n\n\n  labelPattern.lastIndex = 0;\n  var identifierName = '';\n  var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5\n\n  while ((match = labelPattern.exec(styles)) !== null) {\n    identifierName += '-' + // $FlowFixMe we know it's not null\n    match[1];\n  }\n\n  var name = hashString(styles) + identifierName;\n\n  if (process.env.NODE_ENV !== 'production') {\n    // $FlowFixMe SerializedStyles type doesn't have toString property (and we don't want to add it)\n    return {\n      name: name,\n      styles: styles,\n      map: sourceMap,\n      next: cursor,\n      toString: function toString() {\n        return \"You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).\";\n      }\n    };\n  }\n\n  return {\n    name: name,\n    styles: styles,\n    next: cursor\n  };\n};\n\nexport { serializeStyles };\n","import _typeof from \"./typeof.js\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}","var isBrowser = \"object\" !== 'undefined';\nfunction getRegisteredStyles(registered, registeredStyles, classNames) {\n  var rawClassName = '';\n  classNames.split(' ').forEach(function (className) {\n    if (registered[className] !== undefined) {\n      registeredStyles.push(registered[className]);\n    } else {\n      rawClassName += className + \" \";\n    }\n  });\n  return rawClassName;\n}\nvar insertStyles = function insertStyles(cache, serialized, isStringTag) {\n  var className = cache.key + \"-\" + serialized.name;\n\n  if ( // we only need to add the styles to the registered cache if the\n  // class name could be used further down\n  // the tree but if it's a string tag, we know it won't\n  // so we don't have to add it to registered cache.\n  // this improves memory usage since we can avoid storing the whole style string\n  (isStringTag === false || // we need to always store it if we're in compat mode and\n  // in node since emotion-server relies on whether a style is in\n  // the registered cache to know whether a style is global or not\n  // also, note that this check will be dead code eliminated in the browser\n  isBrowser === false && cache.compat !== undefined) && cache.registered[className] === undefined) {\n    cache.registered[className] = serialized.styles;\n  }\n\n  if (cache.inserted[serialized.name] === undefined) {\n    var current = serialized;\n\n    do {\n      var maybeStyles = cache.insert(\".\" + className, current, cache.sheet, true);\n\n      current = current.next;\n    } while (current !== undefined);\n  }\n};\n\nexport { getRegisteredStyles, insertStyles };\n","function _extends() {\n  module.exports = _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _extends.apply(this, arguments);\n}\nmodule.exports = _extends, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nexport default function _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","var objectWithoutPropertiesLoose = require(\"./objectWithoutPropertiesLoose.js\");\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nmodule.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","function stylis_min (W) {\n  function M(d, c, e, h, a) {\n    for (var m = 0, b = 0, v = 0, n = 0, q, g, x = 0, K = 0, k, u = k = q = 0, l = 0, r = 0, I = 0, t = 0, B = e.length, J = B - 1, y, f = '', p = '', F = '', G = '', C; l < B;) {\n      g = e.charCodeAt(l);\n      l === J && 0 !== b + n + v + m && (0 !== b && (g = 47 === b ? 10 : 47), n = v = m = 0, B++, J++);\n\n      if (0 === b + n + v + m) {\n        if (l === J && (0 < r && (f = f.replace(N, '')), 0 < f.trim().length)) {\n          switch (g) {\n            case 32:\n            case 9:\n            case 59:\n            case 13:\n            case 10:\n              break;\n\n            default:\n              f += e.charAt(l);\n          }\n\n          g = 59;\n        }\n\n        switch (g) {\n          case 123:\n            f = f.trim();\n            q = f.charCodeAt(0);\n            k = 1;\n\n            for (t = ++l; l < B;) {\n              switch (g = e.charCodeAt(l)) {\n                case 123:\n                  k++;\n                  break;\n\n                case 125:\n                  k--;\n                  break;\n\n                case 47:\n                  switch (g = e.charCodeAt(l + 1)) {\n                    case 42:\n                    case 47:\n                      a: {\n                        for (u = l + 1; u < J; ++u) {\n                          switch (e.charCodeAt(u)) {\n                            case 47:\n                              if (42 === g && 42 === e.charCodeAt(u - 1) && l + 2 !== u) {\n                                l = u + 1;\n                                break a;\n                              }\n\n                              break;\n\n                            case 10:\n                              if (47 === g) {\n                                l = u + 1;\n                                break a;\n                              }\n\n                          }\n                        }\n\n                        l = u;\n                      }\n\n                  }\n\n                  break;\n\n                case 91:\n                  g++;\n\n                case 40:\n                  g++;\n\n                case 34:\n                case 39:\n                  for (; l++ < J && e.charCodeAt(l) !== g;) {\n                  }\n\n              }\n\n              if (0 === k) break;\n              l++;\n            }\n\n            k = e.substring(t, l);\n            0 === q && (q = (f = f.replace(ca, '').trim()).charCodeAt(0));\n\n            switch (q) {\n              case 64:\n                0 < r && (f = f.replace(N, ''));\n                g = f.charCodeAt(1);\n\n                switch (g) {\n                  case 100:\n                  case 109:\n                  case 115:\n                  case 45:\n                    r = c;\n                    break;\n\n                  default:\n                    r = O;\n                }\n\n                k = M(c, r, k, g, a + 1);\n                t = k.length;\n                0 < A && (r = X(O, f, I), C = H(3, k, r, c, D, z, t, g, a, h), f = r.join(''), void 0 !== C && 0 === (t = (k = C.trim()).length) && (g = 0, k = ''));\n                if (0 < t) switch (g) {\n                  case 115:\n                    f = f.replace(da, ea);\n\n                  case 100:\n                  case 109:\n                  case 45:\n                    k = f + '{' + k + '}';\n                    break;\n\n                  case 107:\n                    f = f.replace(fa, '$1 $2');\n                    k = f + '{' + k + '}';\n                    k = 1 === w || 2 === w && L('@' + k, 3) ? '@-webkit-' + k + '@' + k : '@' + k;\n                    break;\n\n                  default:\n                    k = f + k, 112 === h && (k = (p += k, ''));\n                } else k = '';\n                break;\n\n              default:\n                k = M(c, X(c, f, I), k, h, a + 1);\n            }\n\n            F += k;\n            k = I = r = u = q = 0;\n            f = '';\n            g = e.charCodeAt(++l);\n            break;\n\n          case 125:\n          case 59:\n            f = (0 < r ? f.replace(N, '') : f).trim();\n            if (1 < (t = f.length)) switch (0 === u && (q = f.charCodeAt(0), 45 === q || 96 < q && 123 > q) && (t = (f = f.replace(' ', ':')).length), 0 < A && void 0 !== (C = H(1, f, c, d, D, z, p.length, h, a, h)) && 0 === (t = (f = C.trim()).length) && (f = '\\x00\\x00'), q = f.charCodeAt(0), g = f.charCodeAt(1), q) {\n              case 0:\n                break;\n\n              case 64:\n                if (105 === g || 99 === g) {\n                  G += f + e.charAt(l);\n                  break;\n                }\n\n              default:\n                58 !== f.charCodeAt(t - 1) && (p += P(f, q, g, f.charCodeAt(2)));\n            }\n            I = r = u = q = 0;\n            f = '';\n            g = e.charCodeAt(++l);\n        }\n      }\n\n      switch (g) {\n        case 13:\n        case 10:\n          47 === b ? b = 0 : 0 === 1 + q && 107 !== h && 0 < f.length && (r = 1, f += '\\x00');\n          0 < A * Y && H(0, f, c, d, D, z, p.length, h, a, h);\n          z = 1;\n          D++;\n          break;\n\n        case 59:\n        case 125:\n          if (0 === b + n + v + m) {\n            z++;\n            break;\n          }\n\n        default:\n          z++;\n          y = e.charAt(l);\n\n          switch (g) {\n            case 9:\n            case 32:\n              if (0 === n + m + b) switch (x) {\n                case 44:\n                case 58:\n                case 9:\n                case 32:\n                  y = '';\n                  break;\n\n                default:\n                  32 !== g && (y = ' ');\n              }\n              break;\n\n            case 0:\n              y = '\\\\0';\n              break;\n\n            case 12:\n              y = '\\\\f';\n              break;\n\n            case 11:\n              y = '\\\\v';\n              break;\n\n            case 38:\n              0 === n + b + m && (r = I = 1, y = '\\f' + y);\n              break;\n\n            case 108:\n              if (0 === n + b + m + E && 0 < u) switch (l - u) {\n                case 2:\n                  112 === x && 58 === e.charCodeAt(l - 3) && (E = x);\n\n                case 8:\n                  111 === K && (E = K);\n              }\n              break;\n\n            case 58:\n              0 === n + b + m && (u = l);\n              break;\n\n            case 44:\n              0 === b + v + n + m && (r = 1, y += '\\r');\n              break;\n\n            case 34:\n            case 39:\n              0 === b && (n = n === g ? 0 : 0 === n ? g : n);\n              break;\n\n            case 91:\n              0 === n + b + v && m++;\n              break;\n\n            case 93:\n              0 === n + b + v && m--;\n              break;\n\n            case 41:\n              0 === n + b + m && v--;\n              break;\n\n            case 40:\n              if (0 === n + b + m) {\n                if (0 === q) switch (2 * x + 3 * K) {\n                  case 533:\n                    break;\n\n                  default:\n                    q = 1;\n                }\n                v++;\n              }\n\n              break;\n\n            case 64:\n              0 === b + v + n + m + u + k && (k = 1);\n              break;\n\n            case 42:\n            case 47:\n              if (!(0 < n + m + v)) switch (b) {\n                case 0:\n                  switch (2 * g + 3 * e.charCodeAt(l + 1)) {\n                    case 235:\n                      b = 47;\n                      break;\n\n                    case 220:\n                      t = l, b = 42;\n                  }\n\n                  break;\n\n                case 42:\n                  47 === g && 42 === x && t + 2 !== l && (33 === e.charCodeAt(t + 2) && (p += e.substring(t, l + 1)), y = '', b = 0);\n              }\n          }\n\n          0 === b && (f += y);\n      }\n\n      K = x;\n      x = g;\n      l++;\n    }\n\n    t = p.length;\n\n    if (0 < t) {\n      r = c;\n      if (0 < A && (C = H(2, p, r, d, D, z, t, h, a, h), void 0 !== C && 0 === (p = C).length)) return G + p + F;\n      p = r.join(',') + '{' + p + '}';\n\n      if (0 !== w * E) {\n        2 !== w || L(p, 2) || (E = 0);\n\n        switch (E) {\n          case 111:\n            p = p.replace(ha, ':-moz-$1') + p;\n            break;\n\n          case 112:\n            p = p.replace(Q, '::-webkit-input-$1') + p.replace(Q, '::-moz-$1') + p.replace(Q, ':-ms-input-$1') + p;\n        }\n\n        E = 0;\n      }\n    }\n\n    return G + p + F;\n  }\n\n  function X(d, c, e) {\n    var h = c.trim().split(ia);\n    c = h;\n    var a = h.length,\n        m = d.length;\n\n    switch (m) {\n      case 0:\n      case 1:\n        var b = 0;\n\n        for (d = 0 === m ? '' : d[0] + ' '; b < a; ++b) {\n          c[b] = Z(d, c[b], e).trim();\n        }\n\n        break;\n\n      default:\n        var v = b = 0;\n\n        for (c = []; b < a; ++b) {\n          for (var n = 0; n < m; ++n) {\n            c[v++] = Z(d[n] + ' ', h[b], e).trim();\n          }\n        }\n\n    }\n\n    return c;\n  }\n\n  function Z(d, c, e) {\n    var h = c.charCodeAt(0);\n    33 > h && (h = (c = c.trim()).charCodeAt(0));\n\n    switch (h) {\n      case 38:\n        return c.replace(F, '$1' + d.trim());\n\n      case 58:\n        return d.trim() + c.replace(F, '$1' + d.trim());\n\n      default:\n        if (0 < 1 * e && 0 < c.indexOf('\\f')) return c.replace(F, (58 === d.charCodeAt(0) ? '' : '$1') + d.trim());\n    }\n\n    return d + c;\n  }\n\n  function P(d, c, e, h) {\n    var a = d + ';',\n        m = 2 * c + 3 * e + 4 * h;\n\n    if (944 === m) {\n      d = a.indexOf(':', 9) + 1;\n      var b = a.substring(d, a.length - 1).trim();\n      b = a.substring(0, d).trim() + b + ';';\n      return 1 === w || 2 === w && L(b, 1) ? '-webkit-' + b + b : b;\n    }\n\n    if (0 === w || 2 === w && !L(a, 1)) return a;\n\n    switch (m) {\n      case 1015:\n        return 97 === a.charCodeAt(10) ? '-webkit-' + a + a : a;\n\n      case 951:\n        return 116 === a.charCodeAt(3) ? '-webkit-' + a + a : a;\n\n      case 963:\n        return 110 === a.charCodeAt(5) ? '-webkit-' + a + a : a;\n\n      case 1009:\n        if (100 !== a.charCodeAt(4)) break;\n\n      case 969:\n      case 942:\n        return '-webkit-' + a + a;\n\n      case 978:\n        return '-webkit-' + a + '-moz-' + a + a;\n\n      case 1019:\n      case 983:\n        return '-webkit-' + a + '-moz-' + a + '-ms-' + a + a;\n\n      case 883:\n        if (45 === a.charCodeAt(8)) return '-webkit-' + a + a;\n        if (0 < a.indexOf('image-set(', 11)) return a.replace(ja, '$1-webkit-$2') + a;\n        break;\n\n      case 932:\n        if (45 === a.charCodeAt(4)) switch (a.charCodeAt(5)) {\n          case 103:\n            return '-webkit-box-' + a.replace('-grow', '') + '-webkit-' + a + '-ms-' + a.replace('grow', 'positive') + a;\n\n          case 115:\n            return '-webkit-' + a + '-ms-' + a.replace('shrink', 'negative') + a;\n\n          case 98:\n            return '-webkit-' + a + '-ms-' + a.replace('basis', 'preferred-size') + a;\n        }\n        return '-webkit-' + a + '-ms-' + a + a;\n\n      case 964:\n        return '-webkit-' + a + '-ms-flex-' + a + a;\n\n      case 1023:\n        if (99 !== a.charCodeAt(8)) break;\n        b = a.substring(a.indexOf(':', 15)).replace('flex-', '').replace('space-between', 'justify');\n        return '-webkit-box-pack' + b + '-webkit-' + a + '-ms-flex-pack' + b + a;\n\n      case 1005:\n        return ka.test(a) ? a.replace(aa, ':-webkit-') + a.replace(aa, ':-moz-') + a : a;\n\n      case 1e3:\n        b = a.substring(13).trim();\n        c = b.indexOf('-') + 1;\n\n        switch (b.charCodeAt(0) + b.charCodeAt(c)) {\n          case 226:\n            b = a.replace(G, 'tb');\n            break;\n\n          case 232:\n            b = a.replace(G, 'tb-rl');\n            break;\n\n          case 220:\n            b = a.replace(G, 'lr');\n            break;\n\n          default:\n            return a;\n        }\n\n        return '-webkit-' + a + '-ms-' + b + a;\n\n      case 1017:\n        if (-1 === a.indexOf('sticky', 9)) break;\n\n      case 975:\n        c = (a = d).length - 10;\n        b = (33 === a.charCodeAt(c) ? a.substring(0, c) : a).substring(d.indexOf(':', 7) + 1).trim();\n\n        switch (m = b.charCodeAt(0) + (b.charCodeAt(7) | 0)) {\n          case 203:\n            if (111 > b.charCodeAt(8)) break;\n\n          case 115:\n            a = a.replace(b, '-webkit-' + b) + ';' + a;\n            break;\n\n          case 207:\n          case 102:\n            a = a.replace(b, '-webkit-' + (102 < m ? 'inline-' : '') + 'box') + ';' + a.replace(b, '-webkit-' + b) + ';' + a.replace(b, '-ms-' + b + 'box') + ';' + a;\n        }\n\n        return a + ';';\n\n      case 938:\n        if (45 === a.charCodeAt(5)) switch (a.charCodeAt(6)) {\n          case 105:\n            return b = a.replace('-items', ''), '-webkit-' + a + '-webkit-box-' + b + '-ms-flex-' + b + a;\n\n          case 115:\n            return '-webkit-' + a + '-ms-flex-item-' + a.replace(ba, '') + a;\n\n          default:\n            return '-webkit-' + a + '-ms-flex-line-pack' + a.replace('align-content', '').replace(ba, '') + a;\n        }\n        break;\n\n      case 973:\n      case 989:\n        if (45 !== a.charCodeAt(3) || 122 === a.charCodeAt(4)) break;\n\n      case 931:\n      case 953:\n        if (!0 === la.test(d)) return 115 === (b = d.substring(d.indexOf(':') + 1)).charCodeAt(0) ? P(d.replace('stretch', 'fill-available'), c, e, h).replace(':fill-available', ':stretch') : a.replace(b, '-webkit-' + b) + a.replace(b, '-moz-' + b.replace('fill-', '')) + a;\n        break;\n\n      case 962:\n        if (a = '-webkit-' + a + (102 === a.charCodeAt(5) ? '-ms-' + a : '') + a, 211 === e + h && 105 === a.charCodeAt(13) && 0 < a.indexOf('transform', 10)) return a.substring(0, a.indexOf(';', 27) + 1).replace(ma, '$1-webkit-$2') + a;\n    }\n\n    return a;\n  }\n\n  function L(d, c) {\n    var e = d.indexOf(1 === c ? ':' : '{'),\n        h = d.substring(0, 3 !== c ? e : 10);\n    e = d.substring(e + 1, d.length - 1);\n    return R(2 !== c ? h : h.replace(na, '$1'), e, c);\n  }\n\n  function ea(d, c) {\n    var e = P(c, c.charCodeAt(0), c.charCodeAt(1), c.charCodeAt(2));\n    return e !== c + ';' ? e.replace(oa, ' or ($1)').substring(4) : '(' + c + ')';\n  }\n\n  function H(d, c, e, h, a, m, b, v, n, q) {\n    for (var g = 0, x = c, w; g < A; ++g) {\n      switch (w = S[g].call(B, d, x, e, h, a, m, b, v, n, q)) {\n        case void 0:\n        case !1:\n        case !0:\n        case null:\n          break;\n\n        default:\n          x = w;\n      }\n    }\n\n    if (x !== c) return x;\n  }\n\n  function T(d) {\n    switch (d) {\n      case void 0:\n      case null:\n        A = S.length = 0;\n        break;\n\n      default:\n        if ('function' === typeof d) S[A++] = d;else if ('object' === typeof d) for (var c = 0, e = d.length; c < e; ++c) {\n          T(d[c]);\n        } else Y = !!d | 0;\n    }\n\n    return T;\n  }\n\n  function U(d) {\n    d = d.prefix;\n    void 0 !== d && (R = null, d ? 'function' !== typeof d ? w = 1 : (w = 2, R = d) : w = 0);\n    return U;\n  }\n\n  function B(d, c) {\n    var e = d;\n    33 > e.charCodeAt(0) && (e = e.trim());\n    V = e;\n    e = [V];\n\n    if (0 < A) {\n      var h = H(-1, c, e, e, D, z, 0, 0, 0, 0);\n      void 0 !== h && 'string' === typeof h && (c = h);\n    }\n\n    var a = M(O, e, c, 0, 0);\n    0 < A && (h = H(-2, a, e, e, D, z, a.length, 0, 0, 0), void 0 !== h && (a = h));\n    V = '';\n    E = 0;\n    z = D = 1;\n    return a;\n  }\n\n  var ca = /^\\0+/g,\n      N = /[\\0\\r\\f]/g,\n      aa = /: */g,\n      ka = /zoo|gra/,\n      ma = /([,: ])(transform)/g,\n      ia = /,\\r+?/g,\n      F = /([\\t\\r\\n ])*\\f?&/g,\n      fa = /@(k\\w+)\\s*(\\S*)\\s*/,\n      Q = /::(place)/g,\n      ha = /:(read-only)/g,\n      G = /[svh]\\w+-[tblr]{2}/,\n      da = /\\(\\s*(.*)\\s*\\)/g,\n      oa = /([\\s\\S]*?);/g,\n      ba = /-self|flex-/g,\n      na = /[^]*?(:[rp][el]a[\\w-]+)[^]*/,\n      la = /stretch|:\\s*\\w+\\-(?:conte|avail)/,\n      ja = /([^-])(image-set\\()/,\n      z = 1,\n      D = 1,\n      E = 0,\n      w = 1,\n      O = [],\n      S = [],\n      A = 0,\n      R = null,\n      Y = 0,\n      V = '';\n  B.use = T;\n  B.set = U;\n  void 0 !== W && U(W);\n  return B;\n}\n\nexport default stylis_min;\n","import { StyleSheet } from '@emotion/sheet';\nimport Stylis from '@emotion/stylis';\nimport '@emotion/weak-memoize';\n\n// https://github.com/thysultan/stylis.js/tree/master/plugins/rule-sheet\n// inlined to avoid umd wrapper and peerDep warnings/installing stylis\n// since we use stylis after closure compiler\nvar delimiter = '/*|*/';\nvar needle = delimiter + '}';\n\nfunction toSheet(block) {\n  if (block) {\n    Sheet.current.insert(block + '}');\n  }\n}\n\nvar Sheet = {\n  current: null\n};\nvar ruleSheet = function ruleSheet(context, content, selectors, parents, line, column, length, ns, depth, at) {\n  switch (context) {\n    // property\n    case 1:\n      {\n        switch (content.charCodeAt(0)) {\n          case 64:\n            {\n              // @import\n              Sheet.current.insert(content + ';');\n              return '';\n            }\n          // charcode for l\n\n          case 108:\n            {\n              // charcode for b\n              // this ignores label\n              if (content.charCodeAt(2) === 98) {\n                return '';\n              }\n            }\n        }\n\n        break;\n      }\n    // selector\n\n    case 2:\n      {\n        if (ns === 0) return content + delimiter;\n        break;\n      }\n    // at-rule\n\n    case 3:\n      {\n        switch (ns) {\n          // @font-face, @page\n          case 102:\n          case 112:\n            {\n              Sheet.current.insert(selectors[0] + content);\n              return '';\n            }\n\n          default:\n            {\n              return content + (at === 0 ? delimiter : '');\n            }\n        }\n      }\n\n    case -2:\n      {\n        content.split(needle).forEach(toSheet);\n      }\n  }\n};\n\nvar createCache = function createCache(options) {\n  if (options === undefined) options = {};\n  var key = options.key || 'css';\n  var stylisOptions;\n\n  if (options.prefix !== undefined) {\n    stylisOptions = {\n      prefix: options.prefix\n    };\n  }\n\n  var stylis = new Stylis(stylisOptions);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // $FlowFixMe\n    if (/[^a-z-]/.test(key)) {\n      throw new Error(\"Emotion key must only contain lower case alphabetical characters and - but \\\"\" + key + \"\\\" was passed\");\n    }\n  }\n\n  var inserted = {}; // $FlowFixMe\n\n  var container;\n\n  {\n    container = options.container || document.head;\n    var nodes = document.querySelectorAll(\"style[data-emotion-\" + key + \"]\");\n    Array.prototype.forEach.call(nodes, function (node) {\n      var attrib = node.getAttribute(\"data-emotion-\" + key); // $FlowFixMe\n\n      attrib.split(' ').forEach(function (id) {\n        inserted[id] = true;\n      });\n\n      if (node.parentNode !== container) {\n        container.appendChild(node);\n      }\n    });\n  }\n\n  var _insert;\n\n  {\n    stylis.use(options.stylisPlugins)(ruleSheet);\n\n    _insert = function insert(selector, serialized, sheet, shouldCache) {\n      var name = serialized.name;\n      Sheet.current = sheet;\n\n      if (process.env.NODE_ENV !== 'production' && serialized.map !== undefined) {\n        var map = serialized.map;\n        Sheet.current = {\n          insert: function insert(rule) {\n            sheet.insert(rule + map);\n          }\n        };\n      }\n\n      stylis(selector, serialized.styles);\n\n      if (shouldCache) {\n        cache.inserted[name] = true;\n      }\n    };\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    // https://esbench.com/bench/5bf7371a4cd7e6009ef61d0a\n    var commentStart = /\\/\\*/g;\n    var commentEnd = /\\*\\//g;\n    stylis.use(function (context, content) {\n      switch (context) {\n        case -1:\n          {\n            while (commentStart.test(content)) {\n              commentEnd.lastIndex = commentStart.lastIndex;\n\n              if (commentEnd.test(content)) {\n                commentStart.lastIndex = commentEnd.lastIndex;\n                continue;\n              }\n\n              throw new Error('Your styles have an unterminated comment (\"/*\" without corresponding \"*/\").');\n            }\n\n            commentStart.lastIndex = 0;\n            break;\n          }\n      }\n    });\n    stylis.use(function (context, content, selectors) {\n      switch (context) {\n        case -1:\n          {\n            var flag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason';\n            var unsafePseudoClasses = content.match(/(:first|:nth|:nth-last)-child/g);\n\n            if (unsafePseudoClasses && cache.compat !== true) {\n              unsafePseudoClasses.forEach(function (unsafePseudoClass) {\n                var ignoreRegExp = new RegExp(unsafePseudoClass + \".*\\\\/\\\\* \" + flag + \" \\\\*\\\\/\");\n                var ignore = ignoreRegExp.test(content);\n\n                if (unsafePseudoClass && !ignore) {\n                  console.error(\"The pseudo class \\\"\" + unsafePseudoClass + \"\\\" is potentially unsafe when doing server-side rendering. Try changing it to \\\"\" + unsafePseudoClass.split('-child')[0] + \"-of-type\\\".\");\n                }\n              });\n            }\n\n            break;\n          }\n      }\n    });\n  }\n\n  var cache = {\n    key: key,\n    sheet: new StyleSheet({\n      key: key,\n      container: container,\n      nonce: options.nonce,\n      speedy: options.speedy\n    }),\n    nonce: options.nonce,\n    inserted: inserted,\n    registered: {},\n    insert: _insert\n  };\n  return cache;\n};\n\nexport default createCache;\n","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\n  }\n}\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}"],"sourceRoot":""}