Visible for testing */ const MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android. /** * The percentage of backoff time to randomize by. * See * http://go/safe-client-behavior#step-1-determine-the-appropriate-retry-interval-to-handle-spike-traffic * for context. * *
Visible for testing */ const RANDOM_FACTOR = 0.5; /** * Based on the backoff method from * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js. * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around. */ function calculateBackoffMillis(backoffCount, intervalMillis = DEFAULT_INTERVAL_MILLIS, backoffFactor = DEFAULT_BACKOFF_FACTOR) { // Calculates an exponentially increasing value. // Deviation: calculates value from count and a constant interval, so we only need to save value // and count to restore state. const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount); // A random "fuzz" to avoid waves of retries. // Deviation: randomFactor is required. const randomWait = Math.round( // A fraction of the backoff value to add/subtract. // Deviation: changes multiplication order to improve readability. RANDOM_FACTOR * currBaseValue * ( // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines // if we add or subtract. Math.random() - 0.5) * 2); // Limits backoff to max to avoid effectively permanent backoff. return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait); } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Provide English ordinal letters after a number */ function ordinal(i) { if (!Number.isFinite(i)) { return `${i}`; } return i + indicator(i); } function indicator(i) { i = Math.abs(i); const cent = i % 100; if (cent >= 10 && cent <= 20) { return 'th'; } const dec = i % 10; if (dec === 1) { return 'st'; } if (dec === 2) { return 'nd'; } if (dec === 3) { return 'rd'; } return 'th'; } /** * @license * Copyright 2021 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function getModularInstance(service) { if (service && service._delegate) { return service._delegate; } else { return service; } } /***/ }), /***/ 93087: /*!************************************************************************************!*\ !*** ./node_modules/firebase/node_modules/@firebase/app/dist/esm/index.esm2017.js ***! \************************************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "FirebaseError": () => (/* reexport safe */ _firebase_util__WEBPACK_IMPORTED_MODULE_3__.FirebaseError), /* harmony export */ "SDK_VERSION": () => (/* binding */ SDK_VERSION), /* harmony export */ "_DEFAULT_ENTRY_NAME": () => (/* binding */ DEFAULT_ENTRY_NAME), /* harmony export */ "_addComponent": () => (/* binding */ _addComponent), /* harmony export */ "_addOrOverwriteComponent": () => (/* binding */ _addOrOverwriteComponent), /* harmony export */ "_apps": () => (/* binding */ _apps), /* harmony export */ "_clearComponents": () => (/* binding */ _clearComponents), /* harmony export */ "_components": () => (/* binding */ _components), /* harmony export */ "_getProvider": () => (/* binding */ _getProvider), /* harmony export */ "_isFirebaseApp": () => (/* binding */ _isFirebaseApp), /* harmony export */ "_isFirebaseServerApp": () => (/* binding */ _isFirebaseServerApp), /* harmony export */ "_registerComponent": () => (/* binding */ _registerComponent), /* harmony export */ "_removeServiceInstance": () => (/* binding */ _removeServiceInstance), /* harmony export */ "_serverApps": () => (/* binding */ _serverApps), /* harmony export */ "deleteApp": () => (/* binding */ deleteApp), /* harmony export */ "getApp": () => (/* binding */ getApp), /* harmony export */ "getApps": () => (/* binding */ getApps), /* harmony export */ "initializeApp": () => (/* binding */ initializeApp), /* harmony export */ "initializeServerApp": () => (/* binding */ initializeServerApp), /* harmony export */ "onLog": () => (/* binding */ onLog), /* harmony export */ "registerVersion": () => (/* binding */ registerVersion), /* harmony export */ "setLogLevel": () => (/* binding */ setLogLevel) /* harmony export */ }); /* harmony import */ var _Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js */ 71670); /* harmony import */ var _firebase_component__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @firebase/component */ 21707); /* harmony import */ var _firebase_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @firebase/logger */ 36883); /* harmony import */ var _firebase_util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @firebase/util */ 84850); /* harmony import */ var idb__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! idb */ 60818); /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ class PlatformLoggerServiceImpl { constructor(container) { this.container = container; } // In initial implementation, this will be called by installations on // auth token refresh, and installations will send this string. getPlatformInfoString() { const providers = this.container.getProviders(); // Loop through providers and get library/version pairs from any that are // version components. return providers.map(provider => { if (isVersionServiceProvider(provider)) { const service = provider.getImmediate(); return `${service.library}/${service.version}`; } else { return null; } }).filter(logString => logString).join(' '); } } /** * * @param provider check if this provider provides a VersionService * * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider * provides VersionService. The provider is not necessarily a 'app-version' * provider. */ function isVersionServiceProvider(provider) { const component = provider.getComponent(); return (component === null || component === void 0 ? void 0 : component.type) === "VERSION" /* ComponentType.VERSION */ ; } const name$q = "@firebase/app"; const version$1 = "0.13.2"; /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const logger = new _firebase_logger__WEBPACK_IMPORTED_MODULE_2__.Logger('@firebase/app'); const name$p = "@firebase/app-compat"; const name$o = "@firebase/analytics-compat"; const name$n = "@firebase/analytics"; const name$m = "@firebase/app-check-compat"; const name$l = "@firebase/app-check"; const name$k = "@firebase/auth"; const name$j = "@firebase/auth-compat"; const name$i = "@firebase/database"; const name$h = "@firebase/data-connect"; const name$g = "@firebase/database-compat"; const name$f = "@firebase/functions"; const name$e = "@firebase/functions-compat"; const name$d = "@firebase/installations"; const name$c = "@firebase/installations-compat"; const name$b = "@firebase/messaging"; const name$a = "@firebase/messaging-compat"; const name$9 = "@firebase/performance"; const name$8 = "@firebase/performance-compat"; const name$7 = "@firebase/remote-config"; const name$6 = "@firebase/remote-config-compat"; const name$5 = "@firebase/storage"; const name$4 = "@firebase/storage-compat"; const name$3 = "@firebase/firestore"; const name$2 = "@firebase/ai"; const name$1 = "@firebase/firestore-compat"; const name = "firebase"; const version = "11.10.0"; /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * The default app name * * @internal */ const DEFAULT_ENTRY_NAME = '[DEFAULT]'; const PLATFORM_LOG_STRING = { [name$q]: 'fire-core', [name$p]: 'fire-core-compat', [name$n]: 'fire-analytics', [name$o]: 'fire-analytics-compat', [name$l]: 'fire-app-check', [name$m]: 'fire-app-check-compat', [name$k]: 'fire-auth', [name$j]: 'fire-auth-compat', [name$i]: 'fire-rtdb', [name$h]: 'fire-data-connect', [name$g]: 'fire-rtdb-compat', [name$f]: 'fire-fn', [name$e]: 'fire-fn-compat', [name$d]: 'fire-iid', [name$c]: 'fire-iid-compat', [name$b]: 'fire-fcm', [name$a]: 'fire-fcm-compat', [name$9]: 'fire-perf', [name$8]: 'fire-perf-compat', [name$7]: 'fire-rc', [name$6]: 'fire-rc-compat', [name$5]: 'fire-gcs', [name$4]: 'fire-gcs-compat', [name$3]: 'fire-fst', [name$1]: 'fire-fst-compat', [name$2]: 'fire-vertex', 'fire-js': 'fire-js', // Platform identifier for JS SDK. [name]: 'fire-js-all' }; /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @internal */ const _apps = new Map(); /** * @internal */ const _serverApps = new Map(); /** * Registered components. * * @internal */ // eslint-disable-next-line @typescript-eslint/no-explicit-any const _components = new Map(); /** * @param component - the component being added to this app's container * * @internal */ function _addComponent(app, component) { try { app.container.addComponent(component); } catch (e) { logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app.name}`, e); } } /** * * @internal */ function _addOrOverwriteComponent(app, component) { app.container.addOrOverwriteComponent(component); } /** * * @param component - the component to register * @returns whether or not the component is registered successfully * * @internal */ function _registerComponent(component) { const componentName = component.name; if (_components.has(componentName)) { logger.debug(`There were multiple attempts to register component ${componentName}.`); return false; } _components.set(componentName, component); // add the component to existing app instances for (const app of _apps.values()) { _addComponent(app, component); } for (const serverApp of _serverApps.values()) { _addComponent(serverApp, component); } return true; } /** * * @param app - FirebaseApp instance * @param name - service name * * @returns the provider for the service with the matching name * * @internal */ function _getProvider(app, name) { const heartbeatController = app.container.getProvider('heartbeat').getImmediate({ optional: true }); if (heartbeatController) { void heartbeatController.triggerHeartbeat(); } return app.container.getProvider(name); } /** * * @param app - FirebaseApp instance * @param name - service name * @param instanceIdentifier - service instance identifier in case the service supports multiple instances * * @internal */ function _removeServiceInstance(app, name, instanceIdentifier = DEFAULT_ENTRY_NAME) { _getProvider(app, name).clearInstance(instanceIdentifier); } /** * * @param obj - an object of type FirebaseApp or FirebaseOptions. * * @returns true if the provide object is of type FirebaseApp. * * @internal */ function _isFirebaseApp(obj) { return obj.options !== undefined; } /** * * @param obj - an object of type FirebaseApp. * * @returns true if the provided object is of type FirebaseServerAppImpl. * * @internal */ function _isFirebaseServerApp(obj) { if (obj === null || obj === undefined) { return false; } return obj.settings !== undefined; } /** * Test only * * @internal */ function _clearComponents() { _components.clear(); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const ERRORS = { ["no-app" /* AppError.NO_APP */ ]: "No Firebase App '{$appName}' has been created - " + 'call initializeApp() first', ["bad-app-name" /* AppError.BAD_APP_NAME */ ]: "Illegal App name: '{$appName}'", ["duplicate-app" /* AppError.DUPLICATE_APP */ ]: "Firebase App named '{$appName}' already exists with different options or config", ["app-deleted" /* AppError.APP_DELETED */ ]: "Firebase App named '{$appName}' already deleted", ["server-app-deleted" /* AppError.SERVER_APP_DELETED */ ]: 'Firebase Server App has been deleted', ["no-options" /* AppError.NO_OPTIONS */ ]: 'Need to provide options, when not being deployed to hosting via source.', ["invalid-app-argument" /* AppError.INVALID_APP_ARGUMENT */ ]: 'firebase.{$appName}() takes either no argument or a ' + 'Firebase App instance.', ["invalid-log-argument" /* AppError.INVALID_LOG_ARGUMENT */ ]: 'First argument to `onLog` must be null or a function.', ["idb-open" /* AppError.IDB_OPEN */ ]: 'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.', ["idb-get" /* AppError.IDB_GET */ ]: 'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.', ["idb-set" /* AppError.IDB_WRITE */ ]: 'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.', ["idb-delete" /* AppError.IDB_DELETE */ ]: 'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.', ["finalization-registry-not-supported" /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */ ]: 'FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.', ["invalid-server-app-environment" /* AppError.INVALID_SERVER_APP_ENVIRONMENT */ ]: 'FirebaseServerApp is not for use in browser environments.' }; const ERROR_FACTORY = new _firebase_util__WEBPACK_IMPORTED_MODULE_3__.ErrorFactory('app', 'Firebase', ERRORS); /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ class FirebaseAppImpl { constructor(options, config, container) { this._isDeleted = false; this._options = Object.assign({}, options); this._config = Object.assign({}, config); this._name = config.name; this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled; this._container = container; this.container.addComponent(new _firebase_component__WEBPACK_IMPORTED_MODULE_1__.Component('app', () => this, "PUBLIC" /* ComponentType.PUBLIC */ )); } get automaticDataCollectionEnabled() { this.checkDestroyed(); return this._automaticDataCollectionEnabled; } set automaticDataCollectionEnabled(val) { this.checkDestroyed(); this._automaticDataCollectionEnabled = val; } get name() { this.checkDestroyed(); return this._name; } get options() { this.checkDestroyed(); return this._options; } get config() { this.checkDestroyed(); return this._config; } get container() { return this._container; } get isDeleted() { return this._isDeleted; } set isDeleted(val) { this._isDeleted = val; } /** * This function will throw an Error if the App has already been deleted - * use before performing API actions on the App. */ checkDestroyed() { if (this.isDeleted) { throw ERROR_FACTORY.create("app-deleted" /* AppError.APP_DELETED */ , { appName: this._name }); } } } /** * @license * Copyright 2023 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // Parse the token and check to see if the `exp` claim is in the future. // Reports an error to the console if the token or claim could not be parsed, or if `exp` is in // the past. function validateTokenTTL(base64Token, tokenName) { const secondPart = (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.base64Decode)(base64Token.split('.')[1]); if (secondPart === null) { console.error(`FirebaseServerApp ${tokenName} is invalid: second part could not be parsed.`); return; } const expClaim = JSON.parse(secondPart).exp; if (expClaim === undefined) { console.error(`FirebaseServerApp ${tokenName} is invalid: expiration claim could not be parsed`); return; } const exp = JSON.parse(secondPart).exp * 1000; const now = new Date().getTime(); const diff = exp - now; if (diff <= 0) { console.error(`FirebaseServerApp ${tokenName} is invalid: the token has expired.`); } } class FirebaseServerAppImpl extends FirebaseAppImpl { constructor(options, serverConfig, name, container) { // Build configuration parameters for the FirebaseAppImpl base class. const automaticDataCollectionEnabled = serverConfig.automaticDataCollectionEnabled !== undefined ? serverConfig.automaticDataCollectionEnabled : true; // Create the FirebaseAppSettings object for the FirebaseAppImp constructor. const config = { name, automaticDataCollectionEnabled }; if (options.apiKey !== undefined) { // Construct the parent FirebaseAppImp object. super(options, config, container); } else { const appImpl = options; super(appImpl.options, config, container); } // Now construct the data for the FirebaseServerAppImpl. this._serverConfig = Object.assign({ automaticDataCollectionEnabled }, serverConfig); // Ensure that the current time is within the `authIdtoken` window of validity. if (this._serverConfig.authIdToken) { validateTokenTTL(this._serverConfig.authIdToken, 'authIdToken'); } // Ensure that the current time is within the `appCheckToken` window of validity. if (this._serverConfig.appCheckToken) { validateTokenTTL(this._serverConfig.appCheckToken, 'appCheckToken'); } this._finalizationRegistry = null; if (typeof FinalizationRegistry !== 'undefined') { this._finalizationRegistry = new FinalizationRegistry(() => { this.automaticCleanup(); }); } this._refCount = 0; this.incRefCount(this._serverConfig.releaseOnDeref); // Do not retain a hard reference to the dref object, otherwise the FinalizationRegistry // will never trigger. this._serverConfig.releaseOnDeref = undefined; serverConfig.releaseOnDeref = undefined; registerVersion(name$q, version$1, 'serverapp'); } toJSON() { return undefined; } get refCount() { return this._refCount; } // Increment the reference count of this server app. If an object is provided, register it // with the finalization registry. incRefCount(obj) { if (this.isDeleted) { return; } this._refCount++; if (obj !== undefined && this._finalizationRegistry !== null) { this._finalizationRegistry.register(obj, this); } } // Decrement the reference count. decRefCount() { if (this.isDeleted) { return 0; } return --this._refCount; } // Invoked by the FinalizationRegistry callback to note that this app should go through its // reference counts and delete itself if no reference count remain. The coordinating logic that // handles this is in deleteApp(...). automaticCleanup() { void deleteApp(this); } get settings() { this.checkDestroyed(); return this._serverConfig; } /** * This function will throw an Error if the App has already been deleted - * use before performing API actions on the App. */ checkDestroyed() { if (this.isDeleted) { throw ERROR_FACTORY.create("server-app-deleted" /* AppError.SERVER_APP_DELETED */ ); } } } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * The current SDK version. * * @public */ const SDK_VERSION = version; function initializeApp(_options, rawConfig = {}) { let options = _options; if (typeof rawConfig !== 'object') { const name = rawConfig; rawConfig = { name }; } const config = Object.assign({ name: DEFAULT_ENTRY_NAME, automaticDataCollectionEnabled: true }, rawConfig); const name = config.name; if (typeof name !== 'string' || !name) { throw ERROR_FACTORY.create("bad-app-name" /* AppError.BAD_APP_NAME */ , { appName: String(name) }); } options || (options = (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.getDefaultAppConfig)()); if (!options) { throw ERROR_FACTORY.create("no-options" /* AppError.NO_OPTIONS */ ); } const existingApp = _apps.get(name); if (existingApp) { // return the existing app if options and config deep equal the ones in the existing app. if ((0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.deepEqual)(options, existingApp.options) && (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.deepEqual)(config, existingApp.config)) { return existingApp; } else { throw ERROR_FACTORY.create("duplicate-app" /* AppError.DUPLICATE_APP */ , { appName: name }); } } const container = new _firebase_component__WEBPACK_IMPORTED_MODULE_1__.ComponentContainer(name); for (const component of _components.values()) { container.addComponent(component); } const newApp = new FirebaseAppImpl(options, config, container); _apps.set(name, newApp); return newApp; } function initializeServerApp(_options, _serverAppConfig) { if ((0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.isBrowser)() && !(0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.isWebWorker)()) { // FirebaseServerApp isn't designed to be run in browsers. throw ERROR_FACTORY.create("invalid-server-app-environment" /* AppError.INVALID_SERVER_APP_ENVIRONMENT */ ); } if (_serverAppConfig.automaticDataCollectionEnabled === undefined) { _serverAppConfig.automaticDataCollectionEnabled = true; } let appOptions; if (_isFirebaseApp(_options)) { appOptions = _options.options; } else { appOptions = _options; } // Build an app name based on a hash of the configuration options. const nameObj = Object.assign(Object.assign({}, _serverAppConfig), appOptions); // However, Do not mangle the name based on releaseOnDeref, since it will vary between the // construction of FirebaseServerApp instances. For example, if the object is the request headers. if (nameObj.releaseOnDeref !== undefined) { delete nameObj.releaseOnDeref; } const hashCode = s => { return [...s].reduce((hash, c) => Math.imul(31, hash) + c.charCodeAt(0) | 0, 0); }; if (_serverAppConfig.releaseOnDeref !== undefined) { if (typeof FinalizationRegistry === 'undefined') { throw ERROR_FACTORY.create("finalization-registry-not-supported" /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */ , {}); } } const nameString = '' + hashCode(JSON.stringify(nameObj)); const existingApp = _serverApps.get(nameString); if (existingApp) { existingApp.incRefCount(_serverAppConfig.releaseOnDeref); return existingApp; } const container = new _firebase_component__WEBPACK_IMPORTED_MODULE_1__.ComponentContainer(nameString); for (const component of _components.values()) { container.addComponent(component); } const newApp = new FirebaseServerAppImpl(appOptions, _serverAppConfig, nameString, container); _serverApps.set(nameString, newApp); return newApp; } /** * Retrieves a {@link @firebase/app#FirebaseApp} instance. * * When called with no arguments, the default app is returned. When an app name * is provided, the app corresponding to that name is returned. * * An exception is thrown if the app being retrieved has not yet been * initialized. * * @example * ```javascript * // Return the default app * const app = getApp(); * ``` * * @example * ```javascript * // Return a named app * const otherApp = getApp("otherApp"); * ``` * * @param name - Optional name of the app to return. If no name is * provided, the default is `"[DEFAULT]"`. * * @returns The app corresponding to the provided app name. * If no app name is provided, the default app is returned. * * @public */ function getApp(name = DEFAULT_ENTRY_NAME) { const app = _apps.get(name); if (!app && name === DEFAULT_ENTRY_NAME && (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.getDefaultAppConfig)()) { return initializeApp(); } if (!app) { throw ERROR_FACTORY.create("no-app" /* AppError.NO_APP */ , { appName: name }); } return app; } /** * A (read-only) array of all initialized apps. * @public */ function getApps() { return Array.from(_apps.values()); } /** * Renders this app unusable and frees the resources of all associated * services. * * @example * ```javascript * deleteApp(app) * .then(function() { * console.log("App deleted successfully"); * }) * .catch(function(error) { * console.log("Error deleting app:", error); * }); * ``` * * @public */ function deleteApp(_x) { return _deleteApp.apply(this, arguments); } /** * Registers a library's name and version for platform logging purposes. * @param library - Name of 1p or 3p library (e.g. firestore, angularfire) * @param version - Current version of that library. * @param variant - Bundle variant, e.g., node, rn, etc. * * @public */ function _deleteApp() { _deleteApp = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (app) { let cleanupProviders = false; const name = app.name; if (_apps.has(name)) { cleanupProviders = true; _apps.delete(name); } else if (_serverApps.has(name)) { const firebaseServerApp = app; if (firebaseServerApp.decRefCount() <= 0) { _serverApps.delete(name); cleanupProviders = true; } } if (cleanupProviders) { yield Promise.all(app.container.getProviders().map(provider => provider.delete())); app.isDeleted = true; } }); return _deleteApp.apply(this, arguments); } function registerVersion(libraryKeyOrName, version, variant) { var _a; // TODO: We can use this check to whitelist strings when/if we set up // a good whitelist system. let library = (_a = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a !== void 0 ? _a : libraryKeyOrName; if (variant) { library += `-${variant}`; } const libraryMismatch = library.match(/\s|\//); const versionMismatch = version.match(/\s|\//); if (libraryMismatch || versionMismatch) { const warning = [`Unable to register library "${library}" with version "${version}":`]; if (libraryMismatch) { warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`); } if (libraryMismatch && versionMismatch) { warning.push('and'); } if (versionMismatch) { warning.push(`version name "${version}" contains illegal characters (whitespace or "/")`); } logger.warn(warning.join(' ')); return; } _registerComponent(new _firebase_component__WEBPACK_IMPORTED_MODULE_1__.Component(`${library}-version`, () => ({ library, version }), "VERSION" /* ComponentType.VERSION */ )); } /** * Sets log handler for all Firebase SDKs. * @param logCallback - An optional custom log handler that executes user code whenever * the Firebase SDK makes a logging call. * * @public */ function onLog(logCallback, options) { if (logCallback !== null && typeof logCallback !== 'function') { throw ERROR_FACTORY.create("invalid-log-argument" /* AppError.INVALID_LOG_ARGUMENT */ ); } (0,_firebase_logger__WEBPACK_IMPORTED_MODULE_2__.setUserLogHandler)(logCallback, options); } /** * Sets log level for all Firebase SDKs. * * All of the log types above the current log level are captured (i.e. if * you set the log level to `info`, errors are logged, but `debug` and * `verbose` logs are not). * * @public */ function setLogLevel(logLevel) { (0,_firebase_logger__WEBPACK_IMPORTED_MODULE_2__.setLogLevel)(logLevel); } /** * @license * Copyright 2021 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const DB_NAME = 'firebase-heartbeat-database'; const DB_VERSION = 1; const STORE_NAME = 'firebase-heartbeat-store'; let dbPromise = null; function getDbPromise() { if (!dbPromise) { dbPromise = (0,idb__WEBPACK_IMPORTED_MODULE_4__.openDB)(DB_NAME, DB_VERSION, { upgrade: (db, oldVersion) => { // We don't use 'break' in this switch statement, the fall-through // behavior is what we want, because if there are multiple versions between // the old version and the current version, we want ALL the migrations // that correspond to those versions to run, not only the last one. // eslint-disable-next-line default-case switch (oldVersion) { case 0: try { db.createObjectStore(STORE_NAME); } catch (e) { // Safari/iOS browsers throw occasional exceptions on // db.createObjectStore() that may be a bug. Avoid blocking // the rest of the app functionality. console.warn(e); } } } }).catch(e => { throw ERROR_FACTORY.create("idb-open" /* AppError.IDB_OPEN */ , { originalErrorMessage: e.message }); }); } return dbPromise; } function readHeartbeatsFromIndexedDB(_x2) { return _readHeartbeatsFromIndexedDB.apply(this, arguments); } function _readHeartbeatsFromIndexedDB() { _readHeartbeatsFromIndexedDB = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (app) { try { const db = yield getDbPromise(); const tx = db.transaction(STORE_NAME); const result = yield tx.objectStore(STORE_NAME).get(computeKey(app)); // We already have the value but tx.done can throw, // so we need to await it here to catch errors yield tx.done; return result; } catch (e) { if (e instanceof _firebase_util__WEBPACK_IMPORTED_MODULE_3__.FirebaseError) { logger.warn(e.message); } else { const idbGetError = ERROR_FACTORY.create("idb-get" /* AppError.IDB_GET */ , { originalErrorMessage: e === null || e === void 0 ? void 0 : e.message }); logger.warn(idbGetError.message); } } }); return _readHeartbeatsFromIndexedDB.apply(this, arguments); } function writeHeartbeatsToIndexedDB(_x3, _x4) { return _writeHeartbeatsToIndexedDB.apply(this, arguments); } function _writeHeartbeatsToIndexedDB() { _writeHeartbeatsToIndexedDB = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (app, heartbeatObject) { try { const db = yield getDbPromise(); const tx = db.transaction(STORE_NAME, 'readwrite'); const objectStore = tx.objectStore(STORE_NAME); yield objectStore.put(heartbeatObject, computeKey(app)); yield tx.done; } catch (e) { if (e instanceof _firebase_util__WEBPACK_IMPORTED_MODULE_3__.FirebaseError) { logger.warn(e.message); } else { const idbGetError = ERROR_FACTORY.create("idb-set" /* AppError.IDB_WRITE */ , { originalErrorMessage: e === null || e === void 0 ? void 0 : e.message }); logger.warn(idbGetError.message); } } }); return _writeHeartbeatsToIndexedDB.apply(this, arguments); } function computeKey(app) { return `${app.name}!${app.options.appId}`; } /** * @license * Copyright 2021 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const MAX_HEADER_BYTES = 1024; const MAX_NUM_STORED_HEARTBEATS = 30; class HeartbeatServiceImpl { constructor(container) { this.container = container; /** * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate * the header string. * Stores one record per date. This will be consolidated into the standard * format of one record per user agent string before being sent as a header. * Populated from indexedDB when the controller is instantiated and should * be kept in sync with indexedDB. * Leave public for easier testing. */ this._heartbeatsCache = null; const app = this.container.getProvider('app').getImmediate(); this._storage = new HeartbeatStorageImpl(app); this._heartbeatsCachePromise = this._storage.read().then(result => { this._heartbeatsCache = result; return result; }); } /** * Called to report a heartbeat. The function will generate * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it * to IndexedDB. * Note that we only store one heartbeat per day. So if a heartbeat for today is * already logged, subsequent calls to this function in the same day will be ignored. */ triggerHeartbeat() { var _this = this; return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { var _a, _b; try { const platformLogger = _this.container.getProvider('platform-logger').getImmediate(); // This is the "Firebase user agent" string from the platform logger // service, not the browser user agent. const agent = platformLogger.getPlatformInfoString(); const date = getUTCDateString(); if (((_a = _this._heartbeatsCache) === null || _a === void 0 ? void 0 : _a.heartbeats) == null) { _this._heartbeatsCache = yield _this._heartbeatsCachePromise; // If we failed to construct a heartbeats cache, then return immediately. if (((_b = _this._heartbeatsCache) === null || _b === void 0 ? void 0 : _b.heartbeats) == null) { return; } } // Do not store a heartbeat if one is already stored for this day // or if a header has already been sent today. if (_this._heartbeatsCache.lastSentHeartbeatDate === date || _this._heartbeatsCache.heartbeats.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) { return; } else { // There is no entry for this date. Create one. _this._heartbeatsCache.heartbeats.push({ date, agent }); // If the number of stored heartbeats exceeds the maximum number of stored heartbeats, remove the heartbeat with the earliest date. // Since this is executed each time a heartbeat is pushed, the limit can only be exceeded by one, so only one needs to be removed. if (_this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS) { const earliestHeartbeatIdx = getEarliestHeartbeatIdx(_this._heartbeatsCache.heartbeats); _this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1); } } return _this._storage.overwrite(_this._heartbeatsCache); } catch (e) { logger.warn(e); } })(); } /** * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly. * It also clears all heartbeats from memory as well as in IndexedDB. * * NOTE: Consuming product SDKs should not send the header if this method * returns an empty string. */ getHeartbeatsHeader() { var _this2 = this; return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { var _a; try { if (_this2._heartbeatsCache === null) { yield _this2._heartbeatsCachePromise; } // If it's still null or the array is empty, there is no data to send. if (((_a = _this2._heartbeatsCache) === null || _a === void 0 ? void 0 : _a.heartbeats) == null || _this2._heartbeatsCache.heartbeats.length === 0) { return ''; } const date = getUTCDateString(); // Extract as many heartbeats from the cache as will fit under the size limit. const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(_this2._heartbeatsCache.heartbeats); const headerString = (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.base64urlEncodeWithoutPadding)(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend })); // Store last sent date to prevent another being logged/sent for the same day. _this2._heartbeatsCache.lastSentHeartbeatDate = date; if (unsentEntries.length > 0) { // Store any unsent entries if they exist. _this2._heartbeatsCache.heartbeats = unsentEntries; // This seems more likely than emptying the array (below) to lead to some odd state // since the cache isn't empty and this will be called again on the next request, // and is probably safest if we await it. yield _this2._storage.overwrite(_this2._heartbeatsCache); } else { _this2._heartbeatsCache.heartbeats = []; // Do not wait for this, to reduce latency. void _this2._storage.overwrite(_this2._heartbeatsCache); } return headerString; } catch (e) { logger.warn(e); return ''; } })(); } } function getUTCDateString() { const today = new Date(); // Returns date format 'YYYY-MM-DD' return today.toISOString().substring(0, 10); } function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) { // Heartbeats grouped by user agent in the standard format to be sent in // the header. const heartbeatsToSend = []; // Single date format heartbeats that are not sent. let unsentEntries = heartbeatsCache.slice(); for (const singleDateHeartbeat of heartbeatsCache) { // Look for an existing entry with the same user agent. const heartbeatEntry = heartbeatsToSend.find(hb => hb.agent === singleDateHeartbeat.agent); if (!heartbeatEntry) { // If no entry for this user agent exists, create one. heartbeatsToSend.push({ agent: singleDateHeartbeat.agent, dates: [singleDateHeartbeat.date] }); if (countBytes(heartbeatsToSend) > maxSize) { // If the header would exceed max size, remove the added heartbeat // entry and stop adding to the header. heartbeatsToSend.pop(); break; } } else { heartbeatEntry.dates.push(singleDateHeartbeat.date); // If the header would exceed max size, remove the added date // and stop adding to the header. if (countBytes(heartbeatsToSend) > maxSize) { heartbeatEntry.dates.pop(); break; } } // Pop unsent entry from queue. (Skipped if adding the entry exceeded // quota and the loop breaks early.) unsentEntries = unsentEntries.slice(1); } return { heartbeatsToSend, unsentEntries }; } class HeartbeatStorageImpl { constructor(app) { this.app = app; this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck(); } runIndexedDBEnvironmentCheck() { return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { if (!(0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.isIndexedDBAvailable)()) { return false; } else { return (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.validateIndexedDBOpenable)().then(() => true).catch(() => false); } })(); } /** * Read all heartbeats. */ read() { var _this3 = this; return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { const canUseIndexedDB = yield _this3._canUseIndexedDBPromise; if (!canUseIndexedDB) { return { heartbeats: [] }; } else { const idbHeartbeatObject = yield readHeartbeatsFromIndexedDB(_this3.app); if (idbHeartbeatObject === null || idbHeartbeatObject === void 0 ? void 0 : idbHeartbeatObject.heartbeats) { return idbHeartbeatObject; } else { return { heartbeats: [] }; } } })(); } // overwrite the storage with the provided heartbeats overwrite(heartbeatsObject) { var _this4 = this; return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { var _a; const canUseIndexedDB = yield _this4._canUseIndexedDBPromise; if (!canUseIndexedDB) { return; } else { const existingHeartbeatsObject = yield _this4.read(); return writeHeartbeatsToIndexedDB(_this4.app, { lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate, heartbeats: heartbeatsObject.heartbeats }); } })(); } // add heartbeats add(heartbeatsObject) { var _this5 = this; return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { var _a; const canUseIndexedDB = yield _this5._canUseIndexedDBPromise; if (!canUseIndexedDB) { return; } else { const existingHeartbeatsObject = yield _this5.read(); return writeHeartbeatsToIndexedDB(_this5.app, { lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate, heartbeats: [...existingHeartbeatsObject.heartbeats, ...heartbeatsObject.heartbeats] }); } })(); } } /** * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped * in a platform logging header JSON object, stringified, and converted * to base 64. */ function countBytes(heartbeatsCache) { // base64 has a restricted set of characters, all of which should be 1 byte. return (0,_firebase_util__WEBPACK_IMPORTED_MODULE_3__.base64urlEncodeWithoutPadding)( // heartbeatsCache wrapper properties JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length; } /** * Returns the index of the heartbeat with the earliest date. * If the heartbeats array is empty, -1 is returned. */ function getEarliestHeartbeatIdx(heartbeats) { if (heartbeats.length === 0) { return -1; } let earliestHeartbeatIdx = 0; let earliestHeartbeatDate = heartbeats[0].date; for (let i = 1; i < heartbeats.length; i++) { if (heartbeats[i].date < earliestHeartbeatDate) { earliestHeartbeatDate = heartbeats[i].date; earliestHeartbeatIdx = i; } } return earliestHeartbeatIdx; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function registerCoreComponents(variant) { _registerComponent(new _firebase_component__WEBPACK_IMPORTED_MODULE_1__.Component('platform-logger', container => new PlatformLoggerServiceImpl(container), "PRIVATE" /* ComponentType.PRIVATE */ )); _registerComponent(new _firebase_component__WEBPACK_IMPORTED_MODULE_1__.Component('heartbeat', container => new HeartbeatServiceImpl(container), "PRIVATE" /* ComponentType.PRIVATE */ )); // Register `app` package. registerVersion(name$q, version$1, variant); // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation registerVersion(name$q, version$1, 'esm2017'); // Register platform SDK identifier (no version). registerVersion('fire-js', ''); } /** * Firebase App * * @remarks This package coordinates the communication between the different Firebase components * @packageDocumentation */ registerCoreComponents(''); /***/ }), /***/ 21707: /*!******************************************************************************************!*\ !*** ./node_modules/firebase/node_modules/@firebase/component/dist/esm/index.esm2017.js ***! \******************************************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "Component": () => (/* binding */ Component), /* harmony export */ "ComponentContainer": () => (/* binding */ ComponentContainer), /* harmony export */ "Provider": () => (/* binding */ Provider) /* harmony export */ }); /* harmony import */ var _Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js */ 71670); /* harmony import */ var _firebase_util__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @firebase/util */ 84850); /** * Component for service name T, e.g. `auth`, `auth-internal` */ class Component { /** * * @param name The public service name, e.g. app, auth, firestore, database * @param instanceFactory Service factory responsible for creating the public interface * @param type whether the service provided by the component is public or private */ constructor(name, instanceFactory, type) { this.name = name; this.instanceFactory = instanceFactory; this.type = type; this.multipleInstances = false; /** * Properties to be added to the service namespace */ this.serviceProps = {}; this.instantiationMode = "LAZY" /* InstantiationMode.LAZY */ ; this.onInstanceCreated = null; } setInstantiationMode(mode) { this.instantiationMode = mode; return this; } setMultipleInstances(multipleInstances) { this.multipleInstances = multipleInstances; return this; } setServiceProps(props) { this.serviceProps = props; return this; } setInstanceCreatedCallback(callback) { this.onInstanceCreated = callback; return this; } } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const DEFAULT_ENTRY_NAME = '[DEFAULT]'; /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Provider for instance for service name T, e.g. 'auth', 'auth-internal' * NameServiceMapping[T] is an alias for the type of the instance */ class Provider { constructor(name, container) { this.name = name; this.container = container; this.component = null; this.instances = new Map(); this.instancesDeferred = new Map(); this.instancesOptions = new Map(); this.onInitCallbacks = new Map(); } /** * @param identifier A provider can provide multiple instances of a service * if this.component.multipleInstances is true. */ get(identifier) { // if multipleInstances is not supported, use the default name const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier); if (!this.instancesDeferred.has(normalizedIdentifier)) { const deferred = new _firebase_util__WEBPACK_IMPORTED_MODULE_1__.Deferred(); this.instancesDeferred.set(normalizedIdentifier, deferred); if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) { // initialize the service if it can be auto-initialized try { const instance = this.getOrInitializeService({ instanceIdentifier: normalizedIdentifier }); if (instance) { deferred.resolve(instance); } } catch (e) {// when the instance factory throws an exception during get(), it should not cause // a fatal error. We just return the unresolved promise in this case. } } } return this.instancesDeferred.get(normalizedIdentifier).promise; } getImmediate(options) { var _a; // if multipleInstances is not supported, use the default name const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier); const optional = (_a = options === null || options === void 0 ? void 0 : options.optional) !== null && _a !== void 0 ? _a : false; if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) { try { return this.getOrInitializeService({ instanceIdentifier: normalizedIdentifier }); } catch (e) { if (optional) { return null; } else { throw e; } } } else { // In case a component is not initialized and should/cannot be auto-initialized at the moment, return null if the optional flag is set, or throw if (optional) { return null; } else { throw Error(`Service ${this.name} is not available`); } } } getComponent() { return this.component; } setComponent(component) { if (component.name !== this.name) { throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`); } if (this.component) { throw Error(`Component for ${this.name} has already been provided`); } this.component = component; // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`) if (!this.shouldAutoInitialize()) { return; } // if the service is eager, initialize the default instance if (isComponentEager(component)) { try { this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME }); } catch (e) {// when the instance factory for an eager Component throws an exception during the eager // initialization, it should not cause a fatal error. // TODO: Investigate if we need to make it configurable, because some component may want to cause // a fatal error in this case? } } // Create service instances for the pending promises and resolve them // NOTE: if this.multipleInstances is false, only the default instance will be created // and all promises with resolve with it regardless of the identifier. for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) { const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier); try { // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy. const instance = this.getOrInitializeService({ instanceIdentifier: normalizedIdentifier }); instanceDeferred.resolve(instance); } catch (e) {// when the instance factory throws an exception, it should not cause // a fatal error. We just leave the promise unresolved. } } } clearInstance(identifier = DEFAULT_ENTRY_NAME) { this.instancesDeferred.delete(identifier); this.instancesOptions.delete(identifier); this.instances.delete(identifier); } // app.delete() will call this method on every provider to delete the services // TODO: should we mark the provider as deleted? delete() { var _this = this; return (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* () { const services = Array.from(_this.instances.values()); yield Promise.all([...services.filter(service => 'INTERNAL' in service) // legacy services // eslint-disable-next-line @typescript-eslint/no-explicit-any .map(service => service.INTERNAL.delete()), ...services.filter(service => '_delete' in service) // modularized services // eslint-disable-next-line @typescript-eslint/no-explicit-any .map(service => service._delete())]); })(); } isComponentSet() { return this.component != null; } isInitialized(identifier = DEFAULT_ENTRY_NAME) { return this.instances.has(identifier); } getOptions(identifier = DEFAULT_ENTRY_NAME) { return this.instancesOptions.get(identifier) || {}; } initialize(opts = {}) { const { options = {} } = opts; const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier); if (this.isInitialized(normalizedIdentifier)) { throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`); } if (!this.isComponentSet()) { throw Error(`Component ${this.name} has not been registered yet`); } const instance = this.getOrInitializeService({ instanceIdentifier: normalizedIdentifier, options }); // resolve any pending promise waiting for the service instance for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) { const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier); if (normalizedIdentifier === normalizedDeferredIdentifier) { instanceDeferred.resolve(instance); } } return instance; } /** * * @param callback - a function that will be invoked after the provider has been initialized by calling provider.initialize(). * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program. * * @param identifier An optional instance identifier * @returns a function to unregister the callback */ onInit(callback, identifier) { var _a; const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier); const existingCallbacks = (_a = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a !== void 0 ? _a : new Set(); existingCallbacks.add(callback); this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks); const existingInstance = this.instances.get(normalizedIdentifier); if (existingInstance) { callback(existingInstance, normalizedIdentifier); } return () => { existingCallbacks.delete(callback); }; } /** * Invoke onInit callbacks synchronously * @param instance the service instance` */ invokeOnInitCallbacks(instance, identifier) { const callbacks = this.onInitCallbacks.get(identifier); if (!callbacks) { return; } for (const callback of callbacks) { try { callback(instance, identifier); } catch (_a) {// ignore errors in the onInit callback } } } getOrInitializeService({ instanceIdentifier, options = {} }) { let instance = this.instances.get(instanceIdentifier); if (!instance && this.component) { instance = this.component.instanceFactory(this.container, { instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier), options }); this.instances.set(instanceIdentifier, instance); this.instancesOptions.set(instanceIdentifier, options); /** * Invoke onInit listeners. * Note this.component.onInstanceCreated is different, which is used by the component creator, * while onInit listeners are registered by consumers of the provider. */ this.invokeOnInitCallbacks(instance, instanceIdentifier); /** * Order is important * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which * makes `isInitialized()` return true. */ if (this.component.onInstanceCreated) { try { this.component.onInstanceCreated(this.container, instanceIdentifier, instance); } catch (_a) {// ignore errors in the onInstanceCreatedCallback } } } return instance || null; } normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME) { if (this.component) { return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME; } else { return identifier; // assume multiple instances are supported before the component is provided. } } shouldAutoInitialize() { return !!this.component && this.component.instantiationMode !== "EXPLICIT" /* InstantiationMode.EXPLICIT */ ; } } // undefined should be passed to the service factory for the default instance function normalizeIdentifierForFactory(identifier) { return identifier === DEFAULT_ENTRY_NAME ? undefined : identifier; } function isComponentEager(component) { return component.instantiationMode === "EAGER" /* InstantiationMode.EAGER */ ; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal` */ class ComponentContainer { constructor(name) { this.name = name; this.providers = new Map(); } /** * * @param component Component being added * @param overwrite When a component with the same name has already been registered, * if overwrite is true: overwrite the existing component with the new component and create a new * provider with the new component. It can be useful in tests where you want to use different mocks * for different tests. * if overwrite is false: throw an exception */ addComponent(component) { const provider = this.getProvider(component.name); if (provider.isComponentSet()) { throw new Error(`Component ${component.name} has already been registered with ${this.name}`); } provider.setComponent(component); } addOrOverwriteComponent(component) { const provider = this.getProvider(component.name); if (provider.isComponentSet()) { // delete the existing provider from the container, so we can register the new component this.providers.delete(component.name); } this.addComponent(component); } /** * getProvider provides a type safe interface where it can only be called with a field name * present in NameServiceMapping interface. * * Firebase SDKs providing services should extend NameServiceMapping interface to register * themselves. */ getProvider(name) { if (this.providers.has(name)) { return this.providers.get(name); } // create a Provider for a service that hasn't registered with Firebase const provider = new Provider(name, this); this.providers.set(name, provider); return provider; } getProviders() { return Array.from(this.providers.values()); } } /***/ }), /***/ 43206: /*!**********************************************************************************************!*\ !*** ./node_modules/firebase/node_modules/@firebase/installations/dist/esm/index.esm2017.js ***! \**********************************************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "deleteInstallations": () => (/* binding */ deleteInstallations), /* harmony export */ "getId": () => (/* binding */ getId), /* harmony export */ "getInstallations": () => (/* binding */ getInstallations), /* harmony export */ "getToken": () => (/* binding */ getToken), /* harmony export */ "onIdChange": () => (/* binding */ onIdChange) /* harmony export */ }); /* harmony import */ var _Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js */ 71670); /* harmony import */ var _firebase_app__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @firebase/app */ 93087); /* harmony import */ var _firebase_component__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @firebase/component */ 21707); /* harmony import */ var _firebase_util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @firebase/util */ 84850); /* harmony import */ var idb__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! idb */ 60818); const name = "@firebase/installations"; const version = "0.6.18"; /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const PENDING_TIMEOUT_MS = 10000; const PACKAGE_VERSION = `w:${version}`; const INTERNAL_AUTH_VERSION = 'FIS_v2'; const INSTALLATIONS_API_URL = 'https://firebaseinstallations.googleapis.com/v1'; const TOKEN_EXPIRATION_BUFFER = 60 * 60 * 1000; // One hour const SERVICE = 'installations'; const SERVICE_NAME = 'Installations'; /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const ERROR_DESCRIPTION_MAP = { ["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */ ]: 'Missing App configuration value: "{$valueName}"', ["not-registered" /* ErrorCode.NOT_REGISTERED */ ]: 'Firebase Installation is not registered.', ["installation-not-found" /* ErrorCode.INSTALLATION_NOT_FOUND */ ]: 'Firebase Installation not found.', ["request-failed" /* ErrorCode.REQUEST_FAILED */ ]: '{$requestName} request failed with error "{$serverCode} {$serverStatus}: {$serverMessage}"', ["app-offline" /* ErrorCode.APP_OFFLINE */ ]: 'Could not process request. Application offline.', ["delete-pending-registration" /* ErrorCode.DELETE_PENDING_REGISTRATION */ ]: "Can't delete installation while there is a pending registration request." }; const ERROR_FACTORY = new _firebase_util__WEBPACK_IMPORTED_MODULE_3__.ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP); /** Returns true if error is a FirebaseError that is based on an error from the server. */ function isServerError(error) { return error instanceof _firebase_util__WEBPACK_IMPORTED_MODULE_3__.FirebaseError && error.code.includes("request-failed" /* ErrorCode.REQUEST_FAILED */ ); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function getInstallationsEndpoint({ projectId }) { return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`; } function extractAuthTokenInfoFromResponse(response) { return { token: response.token, requestStatus: 2 /* RequestStatus.COMPLETED */ , expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn), creationTime: Date.now() }; } function getErrorFromResponse(_x, _x2) { return _getErrorFromResponse.apply(this, arguments); } function _getErrorFromResponse() { _getErrorFromResponse = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (requestName, response) { const responseJson = yield response.json(); const errorData = responseJson.error; return ERROR_FACTORY.create("request-failed" /* ErrorCode.REQUEST_FAILED */ , { requestName, serverCode: errorData.code, serverMessage: errorData.message, serverStatus: errorData.status }); }); return _getErrorFromResponse.apply(this, arguments); } function getHeaders({ apiKey }) { return new Headers({ 'Content-Type': 'application/json', Accept: 'application/json', 'x-goog-api-key': apiKey }); } function getHeadersWithAuth(appConfig, { refreshToken }) { const headers = getHeaders(appConfig); headers.append('Authorization', getAuthorizationHeader(refreshToken)); return headers; } /** * Calls the passed in fetch wrapper and returns the response. * If the returned response has a status of 5xx, re-runs the function once and * returns the response. */ function retryIfServerError(_x3) { return _retryIfServerError.apply(this, arguments); } function _retryIfServerError() { _retryIfServerError = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (fn) { const result = yield fn(); if (result.status >= 500 && result.status < 600) { // Internal Server Error. Retry request. return fn(); } return result; }); return _retryIfServerError.apply(this, arguments); } function getExpiresInFromResponseExpiresIn(responseExpiresIn) { // This works because the server will never respond with fractions of a second. return Number(responseExpiresIn.replace('s', '000')); } function getAuthorizationHeader(refreshToken) { return `${INTERNAL_AUTH_VERSION} ${refreshToken}`; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function createInstallationRequest(_x4, _x5) { return _createInstallationRequest.apply(this, arguments); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** Returns a promise that resolves after given time passes. */ function _createInstallationRequest() { _createInstallationRequest = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* ({ appConfig, heartbeatServiceProvider }, { fid }) { const endpoint = getInstallationsEndpoint(appConfig); const headers = getHeaders(appConfig); // If heartbeat service exists, add the heartbeat string to the header. const heartbeatService = heartbeatServiceProvider.getImmediate({ optional: true }); if (heartbeatService) { const heartbeatsHeader = yield heartbeatService.getHeartbeatsHeader(); if (heartbeatsHeader) { headers.append('x-firebase-client', heartbeatsHeader); } } const body = { fid, authVersion: INTERNAL_AUTH_VERSION, appId: appConfig.appId, sdkVersion: PACKAGE_VERSION }; const request = { method: 'POST', headers, body: JSON.stringify(body) }; const response = yield retryIfServerError(() => fetch(endpoint, request)); if (response.ok) { const responseValue = yield response.json(); const registeredInstallationEntry = { fid: responseValue.fid || fid, registrationStatus: 2 /* RequestStatus.COMPLETED */ , refreshToken: responseValue.refreshToken, authToken: extractAuthTokenInfoFromResponse(responseValue.authToken) }; return registeredInstallationEntry; } else { throw yield getErrorFromResponse('Create Installation', response); } }); return _createInstallationRequest.apply(this, arguments); } function sleep(ms) { return new Promise(resolve => { setTimeout(resolve, ms); }); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function bufferToBase64UrlSafe(array) { const b64 = btoa(String.fromCharCode(...array)); return b64.replace(/\+/g, '-').replace(/\//g, '_'); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const VALID_FID_PATTERN = /^[cdef][\w-]{21}$/; const INVALID_FID = ''; /** * Generates a new FID using random values from Web Crypto API. * Returns an empty string if FID generation fails for any reason. */ function generateFid() { try { // A valid FID has exactly 22 base64 characters, which is 132 bits, or 16.5 // bytes. our implementation generates a 17 byte array instead. const fidByteArray = new Uint8Array(17); const crypto = self.crypto || self.msCrypto; crypto.getRandomValues(fidByteArray); // Replace the first 4 random bits with the constant FID header of 0b0111. fidByteArray[0] = 0b01110000 + fidByteArray[0] % 0b00010000; const fid = encode(fidByteArray); return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID; } catch (_a) { // FID generation errored return INVALID_FID; } } /** Converts a FID Uint8Array to a base64 string representation. */ function encode(fidByteArray) { const b64String = bufferToBase64UrlSafe(fidByteArray); // Remove the 23rd character that was added because of the extra 4 bits at the // end of our 17 byte array, and the '=' padding. return b64String.substr(0, 22); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** Returns a string key that can be used to identify the app. */ function getKey(appConfig) { return `${appConfig.appName}!${appConfig.appId}`; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const fidChangeCallbacks = new Map(); /** * Calls the onIdChange callbacks with the new FID value, and broadcasts the * change to other tabs. */ function fidChanged(appConfig, fid) { const key = getKey(appConfig); callFidChangeCallbacks(key, fid); broadcastFidChange(key, fid); } function addCallback(appConfig, callback) { // Open the broadcast channel if it's not already open, // to be able to listen to change events from other tabs. getBroadcastChannel(); const key = getKey(appConfig); let callbackSet = fidChangeCallbacks.get(key); if (!callbackSet) { callbackSet = new Set(); fidChangeCallbacks.set(key, callbackSet); } callbackSet.add(callback); } function removeCallback(appConfig, callback) { const key = getKey(appConfig); const callbackSet = fidChangeCallbacks.get(key); if (!callbackSet) { return; } callbackSet.delete(callback); if (callbackSet.size === 0) { fidChangeCallbacks.delete(key); } // Close broadcast channel if there are no more callbacks. closeBroadcastChannel(); } function callFidChangeCallbacks(key, fid) { const callbacks = fidChangeCallbacks.get(key); if (!callbacks) { return; } for (const callback of callbacks) { callback(fid); } } function broadcastFidChange(key, fid) { const channel = getBroadcastChannel(); if (channel) { channel.postMessage({ key, fid }); } closeBroadcastChannel(); } let broadcastChannel = null; /** Opens and returns a BroadcastChannel if it is supported by the browser. */ function getBroadcastChannel() { if (!broadcastChannel && 'BroadcastChannel' in self) { broadcastChannel = new BroadcastChannel('[Firebase] FID Change'); broadcastChannel.onmessage = e => { callFidChangeCallbacks(e.data.key, e.data.fid); }; } return broadcastChannel; } function closeBroadcastChannel() { if (fidChangeCallbacks.size === 0 && broadcastChannel) { broadcastChannel.close(); broadcastChannel = null; } } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const DATABASE_NAME = 'firebase-installations-database'; const DATABASE_VERSION = 1; const OBJECT_STORE_NAME = 'firebase-installations-store'; let dbPromise = null; function getDbPromise() { if (!dbPromise) { dbPromise = (0,idb__WEBPACK_IMPORTED_MODULE_4__.openDB)(DATABASE_NAME, DATABASE_VERSION, { upgrade: (db, oldVersion) => { // We don't use 'break' in this switch statement, the fall-through // behavior is what we want, because if there are multiple versions between // the old version and the current version, we want ALL the migrations // that correspond to those versions to run, not only the last one. // eslint-disable-next-line default-case switch (oldVersion) { case 0: db.createObjectStore(OBJECT_STORE_NAME); } } }); } return dbPromise; } /** Assigns or overwrites the record for the given key with the given value. */ function set(_x6, _x7) { return _set.apply(this, arguments); } /** Removes record(s) from the objectStore that match the given key. */ function _set() { _set = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (appConfig, value) { const key = getKey(appConfig); const db = yield getDbPromise(); const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite'); const objectStore = tx.objectStore(OBJECT_STORE_NAME); const oldValue = yield objectStore.get(key); yield objectStore.put(value, key); yield tx.done; if (!oldValue || oldValue.fid !== value.fid) { fidChanged(appConfig, value.fid); } return value; }); return _set.apply(this, arguments); } function remove(_x8) { return _remove.apply(this, arguments); } /** * Atomically updates a record with the result of updateFn, which gets * called with the current value. If newValue is undefined, the record is * deleted instead. * @return Updated value */ function _remove() { _remove = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (appConfig) { const key = getKey(appConfig); const db = yield getDbPromise(); const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite'); yield tx.objectStore(OBJECT_STORE_NAME).delete(key); yield tx.done; }); return _remove.apply(this, arguments); } function update(_x9, _x0) { return _update.apply(this, arguments); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Updates and returns the InstallationEntry from the database. * Also triggers a registration request if it is necessary and possible. */ function _update() { _update = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (appConfig, updateFn) { const key = getKey(appConfig); const db = yield getDbPromise(); const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite'); const store = tx.objectStore(OBJECT_STORE_NAME); const oldValue = yield store.get(key); const newValue = updateFn(oldValue); if (newValue === undefined) { yield store.delete(key); } else { yield store.put(newValue, key); } yield tx.done; if (newValue && (!oldValue || oldValue.fid !== newValue.fid)) { fidChanged(appConfig, newValue.fid); } return newValue; }); return _update.apply(this, arguments); } function getInstallationEntry(_x1) { return _getInstallationEntry.apply(this, arguments); } /** * Creates a new Installation Entry if one does not exist. * Also clears timed out pending requests. */ function _getInstallationEntry() { _getInstallationEntry = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations) { let registrationPromise; const installationEntry = yield update(installations.appConfig, oldEntry => { const installationEntry = updateOrCreateInstallationEntry(oldEntry); const entryWithPromise = triggerRegistrationIfNecessary(installations, installationEntry); registrationPromise = entryWithPromise.registrationPromise; return entryWithPromise.installationEntry; }); if (installationEntry.fid === INVALID_FID) { // FID generation failed. Waiting for the FID from the server. return { installationEntry: yield registrationPromise }; } return { installationEntry, registrationPromise }; }); return _getInstallationEntry.apply(this, arguments); } function updateOrCreateInstallationEntry(oldEntry) { const entry = oldEntry || { fid: generateFid(), registrationStatus: 0 /* RequestStatus.NOT_STARTED */ }; return clearTimedOutRequest(entry); } /** * If the Firebase Installation is not registered yet, this will trigger the * registration and return an InProgressInstallationEntry. * * If registrationPromise does not exist, the installationEntry is guaranteed * to be registered. */ function triggerRegistrationIfNecessary(installations, installationEntry) { if (installationEntry.registrationStatus === 0 /* RequestStatus.NOT_STARTED */ ) { if (!navigator.onLine) { // Registration required but app is offline. const registrationPromiseWithError = Promise.reject(ERROR_FACTORY.create("app-offline" /* ErrorCode.APP_OFFLINE */ )); return { installationEntry, registrationPromise: registrationPromiseWithError }; } // Try registering. Change status to IN_PROGRESS. const inProgressEntry = { fid: installationEntry.fid, registrationStatus: 1 /* RequestStatus.IN_PROGRESS */ , registrationTime: Date.now() }; const registrationPromise = registerInstallation(installations, inProgressEntry); return { installationEntry: inProgressEntry, registrationPromise }; } else if (installationEntry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */ ) { return { installationEntry, registrationPromise: waitUntilFidRegistration(installations) }; } else { return { installationEntry }; } } /** This will be executed only once for each new Firebase Installation. */ function registerInstallation(_x10, _x11) { return _registerInstallation.apply(this, arguments); } /** Call if FID registration is pending in another request. */ function _registerInstallation() { _registerInstallation = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations, installationEntry) { try { const registeredInstallationEntry = yield createInstallationRequest(installations, installationEntry); return set(installations.appConfig, registeredInstallationEntry); } catch (e) { if (isServerError(e) && e.customData.serverCode === 409) { // Server returned a "FID cannot be used" error. // Generate a new ID next time. yield remove(installations.appConfig); } else { // Registration failed. Set FID as not registered. yield set(installations.appConfig, { fid: installationEntry.fid, registrationStatus: 0 /* RequestStatus.NOT_STARTED */ }); } throw e; } }); return _registerInstallation.apply(this, arguments); } function waitUntilFidRegistration(_x12) { return _waitUntilFidRegistration.apply(this, arguments); } /** * Called only if there is a CreateInstallation request in progress. * * Updates the InstallationEntry in the DB based on the status of the * CreateInstallation request. * * Returns the updated InstallationEntry. */ function _waitUntilFidRegistration() { _waitUntilFidRegistration = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations) { // Unfortunately, there is no way of reliably observing when a value in // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers), // so we need to poll. let entry = yield updateInstallationRequest(installations.appConfig); while (entry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */ ) { // createInstallation request still in progress. yield sleep(100); entry = yield updateInstallationRequest(installations.appConfig); } if (entry.registrationStatus === 0 /* RequestStatus.NOT_STARTED */ ) { // The request timed out or failed in a different call. Try again. const { installationEntry, registrationPromise } = yield getInstallationEntry(installations); if (registrationPromise) { return registrationPromise; } else { // if there is no registrationPromise, entry is registered. return installationEntry; } } return entry; }); return _waitUntilFidRegistration.apply(this, arguments); } function updateInstallationRequest(appConfig) { return update(appConfig, oldEntry => { if (!oldEntry) { throw ERROR_FACTORY.create("installation-not-found" /* ErrorCode.INSTALLATION_NOT_FOUND */ ); } return clearTimedOutRequest(oldEntry); }); } function clearTimedOutRequest(entry) { if (hasInstallationRequestTimedOut(entry)) { return { fid: entry.fid, registrationStatus: 0 /* RequestStatus.NOT_STARTED */ }; } return entry; } function hasInstallationRequestTimedOut(installationEntry) { return installationEntry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */ && installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now(); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function generateAuthTokenRequest(_x13, _x14) { return _generateAuthTokenRequest.apply(this, arguments); } function _generateAuthTokenRequest() { _generateAuthTokenRequest = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* ({ appConfig, heartbeatServiceProvider }, installationEntry) { const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry); const headers = getHeadersWithAuth(appConfig, installationEntry); // If heartbeat service exists, add the heartbeat string to the header. const heartbeatService = heartbeatServiceProvider.getImmediate({ optional: true }); if (heartbeatService) { const heartbeatsHeader = yield heartbeatService.getHeartbeatsHeader(); if (heartbeatsHeader) { headers.append('x-firebase-client', heartbeatsHeader); } } const body = { installation: { sdkVersion: PACKAGE_VERSION, appId: appConfig.appId } }; const request = { method: 'POST', headers, body: JSON.stringify(body) }; const response = yield retryIfServerError(() => fetch(endpoint, request)); if (response.ok) { const responseValue = yield response.json(); const completedAuthToken = extractAuthTokenInfoFromResponse(responseValue); return completedAuthToken; } else { throw yield getErrorFromResponse('Generate Auth Token', response); } }); return _generateAuthTokenRequest.apply(this, arguments); } function getGenerateAuthTokenEndpoint(appConfig, { fid }) { return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Returns a valid authentication token for the installation. Generates a new * token if one doesn't exist, is expired or about to expire. * * Should only be called if the Firebase Installation is registered. */ function refreshAuthToken(_x15) { return _refreshAuthToken.apply(this, arguments); } /** * Call only if FID is registered and Auth Token request is in progress. * * Waits until the current pending request finishes. If the request times out, * tries once in this thread as well. */ function _refreshAuthToken() { _refreshAuthToken = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations, forceRefresh = false) { let tokenPromise; const entry = yield update(installations.appConfig, oldEntry => { if (!isEntryRegistered(oldEntry)) { throw ERROR_FACTORY.create("not-registered" /* ErrorCode.NOT_REGISTERED */ ); } const oldAuthToken = oldEntry.authToken; if (!forceRefresh && isAuthTokenValid(oldAuthToken)) { // There is a valid token in the DB. return oldEntry; } else if (oldAuthToken.requestStatus === 1 /* RequestStatus.IN_PROGRESS */ ) { // There already is a token request in progress. tokenPromise = waitUntilAuthTokenRequest(installations, forceRefresh); return oldEntry; } else { // No token or token expired. if (!navigator.onLine) { throw ERROR_FACTORY.create("app-offline" /* ErrorCode.APP_OFFLINE */ ); } const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry); tokenPromise = fetchAuthTokenFromServer(installations, inProgressEntry); return inProgressEntry; } }); const authToken = tokenPromise ? yield tokenPromise : entry.authToken; return authToken; }); return _refreshAuthToken.apply(this, arguments); } function waitUntilAuthTokenRequest(_x16, _x17) { return _waitUntilAuthTokenRequest.apply(this, arguments); } /** * Called only if there is a GenerateAuthToken request in progress. * * Updates the InstallationEntry in the DB based on the status of the * GenerateAuthToken request. * * Returns the updated InstallationEntry. */ function _waitUntilAuthTokenRequest() { _waitUntilAuthTokenRequest = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations, forceRefresh) { // Unfortunately, there is no way of reliably observing when a value in // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers), // so we need to poll. let entry = yield updateAuthTokenRequest(installations.appConfig); while (entry.authToken.requestStatus === 1 /* RequestStatus.IN_PROGRESS */ ) { // generateAuthToken still in progress. yield sleep(100); entry = yield updateAuthTokenRequest(installations.appConfig); } const authToken = entry.authToken; if (authToken.requestStatus === 0 /* RequestStatus.NOT_STARTED */ ) { // The request timed out or failed in a different call. Try again. return refreshAuthToken(installations, forceRefresh); } else { return authToken; } }); return _waitUntilAuthTokenRequest.apply(this, arguments); } function updateAuthTokenRequest(appConfig) { return update(appConfig, oldEntry => { if (!isEntryRegistered(oldEntry)) { throw ERROR_FACTORY.create("not-registered" /* ErrorCode.NOT_REGISTERED */ ); } const oldAuthToken = oldEntry.authToken; if (hasAuthTokenRequestTimedOut(oldAuthToken)) { return Object.assign(Object.assign({}, oldEntry), { authToken: { requestStatus: 0 /* RequestStatus.NOT_STARTED */ } }); } return oldEntry; }); } function fetchAuthTokenFromServer(_x18, _x19) { return _fetchAuthTokenFromServer.apply(this, arguments); } function _fetchAuthTokenFromServer() { _fetchAuthTokenFromServer = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations, installationEntry) { try { const authToken = yield generateAuthTokenRequest(installations, installationEntry); const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken }); yield set(installations.appConfig, updatedInstallationEntry); return authToken; } catch (e) { if (isServerError(e) && (e.customData.serverCode === 401 || e.customData.serverCode === 404)) { // Server returned a "FID not found" or a "Invalid authentication" error. // Generate a new ID next time. yield remove(installations.appConfig); } else { const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken: { requestStatus: 0 /* RequestStatus.NOT_STARTED */ } }); yield set(installations.appConfig, updatedInstallationEntry); } throw e; } }); return _fetchAuthTokenFromServer.apply(this, arguments); } function isEntryRegistered(installationEntry) { return installationEntry !== undefined && installationEntry.registrationStatus === 2 /* RequestStatus.COMPLETED */ ; } function isAuthTokenValid(authToken) { return authToken.requestStatus === 2 /* RequestStatus.COMPLETED */ && !isAuthTokenExpired(authToken); } function isAuthTokenExpired(authToken) { const now = Date.now(); return now < authToken.creationTime || authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER; } /** Returns an updated InstallationEntry with an InProgressAuthToken. */ function makeAuthTokenRequestInProgressEntry(oldEntry) { const inProgressAuthToken = { requestStatus: 1 /* RequestStatus.IN_PROGRESS */ , requestTime: Date.now() }; return Object.assign(Object.assign({}, oldEntry), { authToken: inProgressAuthToken }); } function hasAuthTokenRequestTimedOut(authToken) { return authToken.requestStatus === 1 /* RequestStatus.IN_PROGRESS */ && authToken.requestTime + PENDING_TIMEOUT_MS < Date.now(); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Creates a Firebase Installation if there isn't one for the app and * returns the Installation ID. * @param installations - The `Installations` instance. * * @public */ function getId(_x20) { return _getId.apply(this, arguments); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Returns a Firebase Installations auth token, identifying the current * Firebase Installation. * @param installations - The `Installations` instance. * @param forceRefresh - Force refresh regardless of token expiration. * * @public */ function _getId() { _getId = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations) { const installationsImpl = installations; const { installationEntry, registrationPromise } = yield getInstallationEntry(installationsImpl); if (registrationPromise) { registrationPromise.catch(console.error); } else { // If the installation is already registered, update the authentication // token if needed. refreshAuthToken(installationsImpl).catch(console.error); } return installationEntry.fid; }); return _getId.apply(this, arguments); } function getToken(_x21) { return _getToken.apply(this, arguments); } function _getToken() { _getToken = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations, forceRefresh = false) { const installationsImpl = installations; yield completeInstallationRegistration(installationsImpl); // At this point we either have a Registered Installation in the DB, or we've // already thrown an error. const authToken = yield refreshAuthToken(installationsImpl, forceRefresh); return authToken.token; }); return _getToken.apply(this, arguments); } function completeInstallationRegistration(_x22) { return _completeInstallationRegistration.apply(this, arguments); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function _completeInstallationRegistration() { _completeInstallationRegistration = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations) { const { registrationPromise } = yield getInstallationEntry(installations); if (registrationPromise) { // A createInstallation request is in progress. Wait until it finishes. yield registrationPromise; } }); return _completeInstallationRegistration.apply(this, arguments); } function deleteInstallationRequest(_x23, _x24) { return _deleteInstallationRequest.apply(this, arguments); } function _deleteInstallationRequest() { _deleteInstallationRequest = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (appConfig, installationEntry) { const endpoint = getDeleteEndpoint(appConfig, installationEntry); const headers = getHeadersWithAuth(appConfig, installationEntry); const request = { method: 'DELETE', headers }; const response = yield retryIfServerError(() => fetch(endpoint, request)); if (!response.ok) { throw yield getErrorFromResponse('Delete Installation', response); } }); return _deleteInstallationRequest.apply(this, arguments); } function getDeleteEndpoint(appConfig, { fid }) { return `${getInstallationsEndpoint(appConfig)}/${fid}`; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Deletes the Firebase Installation and all associated data. * @param installations - The `Installations` instance. * * @public */ function deleteInstallations(_x25) { return _deleteInstallations.apply(this, arguments); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Sets a new callback that will get called when Installation ID changes. * Returns an unsubscribe function that will remove the callback when called. * @param installations - The `Installations` instance. * @param callback - The callback function that is invoked when FID changes. * @returns A function that can be called to unsubscribe. * * @public */ function _deleteInstallations() { _deleteInstallations = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (installations) { const { appConfig } = installations; const entry = yield update(appConfig, oldEntry => { if (oldEntry && oldEntry.registrationStatus === 0 /* RequestStatus.NOT_STARTED */ ) { // Delete the unregistered entry without sending a deleteInstallation request. return undefined; } return oldEntry; }); if (entry) { if (entry.registrationStatus === 1 /* RequestStatus.IN_PROGRESS */ ) { // Can't delete while trying to register. throw ERROR_FACTORY.create("delete-pending-registration" /* ErrorCode.DELETE_PENDING_REGISTRATION */ ); } else if (entry.registrationStatus === 2 /* RequestStatus.COMPLETED */ ) { if (!navigator.onLine) { throw ERROR_FACTORY.create("app-offline" /* ErrorCode.APP_OFFLINE */ ); } else { yield deleteInstallationRequest(appConfig, entry); yield remove(appConfig); } } } }); return _deleteInstallations.apply(this, arguments); } function onIdChange(installations, callback) { const { appConfig } = installations; addCallback(appConfig, callback); return () => { removeCallback(appConfig, callback); }; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Returns an instance of {@link Installations} associated with the given * {@link @firebase/app#FirebaseApp} instance. * @param app - The {@link @firebase/app#FirebaseApp} instance. * * @public */ function getInstallations(app = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__.getApp)()) { const installationsImpl = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__._getProvider)(app, 'installations').getImmediate(); return installationsImpl; } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function extractAppConfig(app) { if (!app || !app.options) { throw getMissingValueError('App Configuration'); } if (!app.name) { throw getMissingValueError('App Name'); } // Required app config keys const configKeys = ['projectId', 'apiKey', 'appId']; for (const keyName of configKeys) { if (!app.options[keyName]) { throw getMissingValueError(keyName); } } return { appName: app.name, projectId: app.options.projectId, apiKey: app.options.apiKey, appId: app.options.appId }; } function getMissingValueError(valueName) { return ERROR_FACTORY.create("missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */ , { valueName }); } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const INSTALLATIONS_NAME = 'installations'; const INSTALLATIONS_NAME_INTERNAL = 'installations-internal'; const publicFactory = container => { const app = container.getProvider('app').getImmediate(); // Throws if app isn't configured properly. const appConfig = extractAppConfig(app); const heartbeatServiceProvider = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__._getProvider)(app, 'heartbeat'); const installationsImpl = { app, appConfig, heartbeatServiceProvider, _delete: () => Promise.resolve() }; return installationsImpl; }; const internalFactory = container => { const app = container.getProvider('app').getImmediate(); // Internal FIS instance relies on public FIS instance. const installations = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__._getProvider)(app, INSTALLATIONS_NAME).getImmediate(); const installationsInternal = { getId: () => getId(installations), getToken: forceRefresh => getToken(installations, forceRefresh) }; return installationsInternal; }; function registerInstallations() { (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__._registerComponent)(new _firebase_component__WEBPACK_IMPORTED_MODULE_2__.Component(INSTALLATIONS_NAME, publicFactory, "PUBLIC" /* ComponentType.PUBLIC */ )); (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__._registerComponent)(new _firebase_component__WEBPACK_IMPORTED_MODULE_2__.Component(INSTALLATIONS_NAME_INTERNAL, internalFactory, "PRIVATE" /* ComponentType.PRIVATE */ )); } /** * The Firebase Installations Web SDK. * This SDK does not work in a Node.js environment. * * @packageDocumentation */ registerInstallations(); (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__.registerVersion)(name, version); // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation (0,_firebase_app__WEBPACK_IMPORTED_MODULE_1__.registerVersion)(name, version, 'esm2017'); /***/ }), /***/ 36883: /*!***************************************************************************************!*\ !*** ./node_modules/firebase/node_modules/@firebase/logger/dist/esm/index.esm2017.js ***! \***************************************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "LogLevel": () => (/* binding */ LogLevel), /* harmony export */ "Logger": () => (/* binding */ Logger), /* harmony export */ "setLogLevel": () => (/* binding */ setLogLevel), /* harmony export */ "setUserLogHandler": () => (/* binding */ setUserLogHandler) /* harmony export */ }); /** * @license * Copyright 2017 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * A container for all of the Logger instances */ const instances = []; /** * The JS SDK supports 5 log levels and also allows a user the ability to * silence the logs altogether. * * The order is a follows: * DEBUG < VERBOSE < INFO < WARN < ERROR * * All of the log types above the current log level will be captured (i.e. if * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and * `VERBOSE` logs will not) */ var LogLevel; (function (LogLevel) { LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG"; LogLevel[LogLevel["VERBOSE"] = 1] = "VERBOSE"; LogLevel[LogLevel["INFO"] = 2] = "INFO"; LogLevel[LogLevel["WARN"] = 3] = "WARN"; LogLevel[LogLevel["ERROR"] = 4] = "ERROR"; LogLevel[LogLevel["SILENT"] = 5] = "SILENT"; })(LogLevel || (LogLevel = {})); const levelStringToEnum = { 'debug': LogLevel.DEBUG, 'verbose': LogLevel.VERBOSE, 'info': LogLevel.INFO, 'warn': LogLevel.WARN, 'error': LogLevel.ERROR, 'silent': LogLevel.SILENT }; /** * The default log level */ const defaultLogLevel = LogLevel.INFO; /** * By default, `console.debug` is not displayed in the developer console (in * chrome). To avoid forcing users to have to opt-in to these logs twice * (i.e. once for firebase, and once in the console), we are sending `DEBUG` * logs to the `console.log` function. */ const ConsoleMethod = { [LogLevel.DEBUG]: 'log', [LogLevel.VERBOSE]: 'log', [LogLevel.INFO]: 'info', [LogLevel.WARN]: 'warn', [LogLevel.ERROR]: 'error' }; /** * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR * messages on to their corresponding console counterparts (if the log method * is supported by the current log level) */ const defaultLogHandler = (instance, logType, ...args) => { if (logType < instance.logLevel) { return; } const now = new Date().toISOString(); const method = ConsoleMethod[logType]; if (method) { console[method](`[${now}] ${instance.name}:`, ...args); } else { throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`); } }; class Logger { /** * Gives you an instance of a Logger to capture messages according to * Firebase's logging scheme. * * @param name The name that the logs will be associated with */ constructor(name) { this.name = name; /** * The log level of the given Logger instance. */ this._logLevel = defaultLogLevel; /** * The main (internal) log handler for the Logger instance. * Can be set to a new function in internal package code but not by user. */ this._logHandler = defaultLogHandler; /** * The optional, additional, user-defined log handler for the Logger instance. */ this._userLogHandler = null; /** * Capture the current instance for later use */ instances.push(this); } get logLevel() { return this._logLevel; } set logLevel(val) { if (!(val in LogLevel)) { throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``); } this._logLevel = val; } // Workaround for setter/getter having to be the same type. setLogLevel(val) { this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val; } get logHandler() { return this._logHandler; } set logHandler(val) { if (typeof val !== 'function') { throw new TypeError('Value assigned to `logHandler` must be a function'); } this._logHandler = val; } get userLogHandler() { return this._userLogHandler; } set userLogHandler(val) { this._userLogHandler = val; } /** * The functions below are all based on the `console` interface */ debug(...args) { this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args); this._logHandler(this, LogLevel.DEBUG, ...args); } log(...args) { this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args); this._logHandler(this, LogLevel.VERBOSE, ...args); } info(...args) { this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args); this._logHandler(this, LogLevel.INFO, ...args); } warn(...args) { this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args); this._logHandler(this, LogLevel.WARN, ...args); } error(...args) { this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args); this._logHandler(this, LogLevel.ERROR, ...args); } } function setLogLevel(level) { instances.forEach(inst => { inst.setLogLevel(level); }); } function setUserLogHandler(logCallback, options) { for (const instance of instances) { let customLogLevel = null; if (options && options.level) { customLogLevel = levelStringToEnum[options.level]; } if (logCallback === null) { instance.userLogHandler = null; } else { instance.userLogHandler = (instance, level, ...args) => { const message = args.map(arg => { if (arg == null) { return null; } else if (typeof arg === 'string') { return arg; } else if (typeof arg === 'number' || typeof arg === 'boolean') { return arg.toString(); } else if (arg instanceof Error) { return arg.message; } else { try { return JSON.stringify(arg); } catch (ignored) { return null; } } }).filter(arg => arg).join(' '); if (level >= (customLogLevel !== null && customLogLevel !== void 0 ? customLogLevel : instance.logLevel)) { logCallback({ level: LogLevel[level].toLowerCase(), message, args, type: instance.name }); } }; } } } /***/ }), /***/ 87823: /*!********************************************************************************************!*\ !*** ./node_modules/firebase/node_modules/@firebase/performance/dist/esm/index.esm2017.js ***! \********************************************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "getPerformance": () => (/* binding */ getPerformance), /* harmony export */ "initializePerformance": () => (/* binding */ initializePerformance), /* harmony export */ "trace": () => (/* binding */ trace) /* harmony export */ }); /* harmony import */ var _firebase_util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @firebase/util */ 84850); /* harmony import */ var _firebase_logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @firebase/logger */ 36883); /* harmony import */ var web_vitals_attribution__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! web-vitals/attribution */ 471); /* harmony import */ var _firebase_app__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @firebase/app */ 93087); /* harmony import */ var _firebase_component__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @firebase/component */ 21707); /* harmony import */ var _firebase_installations__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @firebase/installations */ 43206); const name = "@firebase/performance"; const version = "0.7.7"; /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const SDK_VERSION = version; /** The prefix for start User Timing marks used for creating Traces. */ const TRACE_START_MARK_PREFIX = 'FB-PERF-TRACE-START'; /** The prefix for stop User Timing marks used for creating Traces. */ const TRACE_STOP_MARK_PREFIX = 'FB-PERF-TRACE-STOP'; /** The prefix for User Timing measure used for creating Traces. */ const TRACE_MEASURE_PREFIX = 'FB-PERF-TRACE-MEASURE'; /** The prefix for out of the box page load Trace name. */ const OOB_TRACE_PAGE_LOAD_PREFIX = '_wt_'; const FIRST_PAINT_COUNTER_NAME = '_fp'; const FIRST_CONTENTFUL_PAINT_COUNTER_NAME = '_fcp'; const FIRST_INPUT_DELAY_COUNTER_NAME = '_fid'; const LARGEST_CONTENTFUL_PAINT_METRIC_NAME = '_lcp'; const LARGEST_CONTENTFUL_PAINT_ATTRIBUTE_NAME = 'lcp_element'; const INTERACTION_TO_NEXT_PAINT_METRIC_NAME = '_inp'; const INTERACTION_TO_NEXT_PAINT_ATTRIBUTE_NAME = 'inp_interactionTarget'; const CUMULATIVE_LAYOUT_SHIFT_METRIC_NAME = '_cls'; const CUMULATIVE_LAYOUT_SHIFT_ATTRIBUTE_NAME = 'cls_largestShiftTarget'; const CONFIG_LOCAL_STORAGE_KEY = '@firebase/performance/config'; const CONFIG_EXPIRY_LOCAL_STORAGE_KEY = '@firebase/performance/configexpire'; const SERVICE = 'performance'; const SERVICE_NAME = 'Performance'; /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const ERROR_DESCRIPTION_MAP = { ["trace started" /* ErrorCode.TRACE_STARTED_BEFORE */ ]: 'Trace {$traceName} was started before.', ["trace stopped" /* ErrorCode.TRACE_STOPPED_BEFORE */ ]: 'Trace {$traceName} is not running.', ["nonpositive trace startTime" /* ErrorCode.NONPOSITIVE_TRACE_START_TIME */ ]: 'Trace {$traceName} startTime should be positive.', ["nonpositive trace duration" /* ErrorCode.NONPOSITIVE_TRACE_DURATION */ ]: 'Trace {$traceName} duration should be positive.', ["no window" /* ErrorCode.NO_WINDOW */ ]: 'Window is not available.', ["no app id" /* ErrorCode.NO_APP_ID */ ]: 'App id is not available.', ["no project id" /* ErrorCode.NO_PROJECT_ID */ ]: 'Project id is not available.', ["no api key" /* ErrorCode.NO_API_KEY */ ]: 'Api key is not available.', ["invalid cc log" /* ErrorCode.INVALID_CC_LOG */ ]: 'Attempted to queue invalid cc event', ["FB not default" /* ErrorCode.FB_NOT_DEFAULT */ ]: 'Performance can only start when Firebase app instance is the default one.', ["RC response not ok" /* ErrorCode.RC_NOT_OK */ ]: 'RC response is not ok', ["invalid attribute name" /* ErrorCode.INVALID_ATTRIBUTE_NAME */ ]: 'Attribute name {$attributeName} is invalid.', ["invalid attribute value" /* ErrorCode.INVALID_ATTRIBUTE_VALUE */ ]: 'Attribute value {$attributeValue} is invalid.', ["invalid custom metric name" /* ErrorCode.INVALID_CUSTOM_METRIC_NAME */ ]: 'Custom metric name {$customMetricName} is invalid', ["invalid String merger input" /* ErrorCode.INVALID_STRING_MERGER_PARAMETER */ ]: 'Input for String merger is invalid, contact support team to resolve.', ["already initialized" /* ErrorCode.ALREADY_INITIALIZED */ ]: 'initializePerformance() has already been called with ' + 'different options. To avoid this error, call initializePerformance() with the ' + 'same options as when it was originally called, or call getPerformance() to return the' + ' already initialized instance.' }; const ERROR_FACTORY = new _firebase_util__WEBPACK_IMPORTED_MODULE_0__.ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP); /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const consoleLogger = new _firebase_logger__WEBPACK_IMPORTED_MODULE_1__.Logger(SERVICE_NAME); consoleLogger.logLevel = _firebase_logger__WEBPACK_IMPORTED_MODULE_1__.LogLevel.INFO; /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ let apiInstance; let windowInstance; /** * This class holds a reference to various browser related objects injected by * set methods. */ class Api { constructor(window) { this.window = window; if (!window) { throw ERROR_FACTORY.create("no window" /* ErrorCode.NO_WINDOW */ ); } this.performance = window.performance; this.PerformanceObserver = window.PerformanceObserver; this.windowLocation = window.location; this.navigator = window.navigator; this.document = window.document; if (this.navigator && this.navigator.cookieEnabled) { // If user blocks cookies on the browser, accessing localStorage will // throw an exception. this.localStorage = window.localStorage; } if (window.perfMetrics && window.perfMetrics.onFirstInputDelay) { this.onFirstInputDelay = window.perfMetrics.onFirstInputDelay; } this.onLCP = web_vitals_attribution__WEBPACK_IMPORTED_MODULE_2__.onLCP; this.onINP = web_vitals_attribution__WEBPACK_IMPORTED_MODULE_2__.onINP; this.onCLS = web_vitals_attribution__WEBPACK_IMPORTED_MODULE_2__.onCLS; } getUrl() { // Do not capture the string query part of url. return this.windowLocation.href.split('?')[0]; } mark(name) { if (!this.performance || !this.performance.mark) { return; } this.performance.mark(name); } measure(measureName, mark1, mark2) { if (!this.performance || !this.performance.measure) { return; } this.performance.measure(measureName, mark1, mark2); } getEntriesByType(type) { if (!this.performance || !this.performance.getEntriesByType) { return []; } return this.performance.getEntriesByType(type); } getEntriesByName(name) { if (!this.performance || !this.performance.getEntriesByName) { return []; } return this.performance.getEntriesByName(name); } getTimeOrigin() { // Polyfill the time origin with performance.timing.navigationStart. return this.performance && (this.performance.timeOrigin || this.performance.timing.navigationStart); } requiredApisAvailable() { if (!fetch || !Promise || !(0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.areCookiesEnabled)()) { consoleLogger.info('Firebase Performance cannot start if browser does not support fetch and Promise or cookie is disabled.'); return false; } if (!(0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.isIndexedDBAvailable)()) { consoleLogger.info('IndexedDB is not supported by current browser'); return false; } return true; } setupObserver(entryType, callback) { if (!this.PerformanceObserver) { return; } const observer = new this.PerformanceObserver(list => { for (const entry of list.getEntries()) { // `entry` is a PerformanceEntry instance. callback(entry); } }); // Start observing the entry types you care about. observer.observe({ entryTypes: [entryType] }); } static getInstance() { if (apiInstance === undefined) { apiInstance = new Api(windowInstance); } return apiInstance; } } function setupApi(window) { windowInstance = window; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ let iid; function getIidPromise(installationsService) { const iidPromise = installationsService.getId(); // eslint-disable-next-line @typescript-eslint/no-floating-promises iidPromise.then(iidVal => { iid = iidVal; }); return iidPromise; } // This method should be used after the iid is retrieved by getIidPromise method. function getIid() { return iid; } function getAuthTokenPromise(installationsService) { const authTokenPromise = installationsService.getToken(); // eslint-disable-next-line @typescript-eslint/no-floating-promises authTokenPromise.then(authTokenVal => {}); return authTokenPromise; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function mergeStrings(part1, part2) { const sizeDiff = part1.length - part2.length; if (sizeDiff < 0 || sizeDiff > 1) { throw ERROR_FACTORY.create("invalid String merger input" /* ErrorCode.INVALID_STRING_MERGER_PARAMETER */ ); } const resultArray = []; for (let i = 0; i < part1.length; i++) { resultArray.push(part1.charAt(i)); if (part2.length > i) { resultArray.push(part2.charAt(i)); } } return resultArray.join(''); } /** * @license * Copyright 2019 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ let settingsServiceInstance; class SettingsService { constructor() { // The variable which controls logging of automatic traces and HTTP/S network monitoring. this.instrumentationEnabled = true; // The variable which controls logging of custom traces. this.dataCollectionEnabled = true; // Configuration flags set through remote config. this.loggingEnabled = false; // Sampling rate between 0 and 1. this.tracesSamplingRate = 1; this.networkRequestsSamplingRate = 1; // Address of logging service. this.logEndPointUrl = 'https://firebaselogging.googleapis.com/v0cc/log?format=json_proto'; // Performance event transport endpoint URL which should be compatible with proto3. // New Address for transport service, not configurable via Remote Config. this.flTransportEndpointUrl = mergeStrings('hts/frbslgigp.ogepscmv/ieo/eaylg', 'tp:/ieaeogn-agolai.o/1frlglgc/o'); this.transportKey = mergeStrings('AzSC8r6ReiGqFMyfvgow', 'Iayx0u-XT3vksVM-pIV'); // Source type for performance event logs. this.logSource = 462; // Flags which control per session logging of traces and network requests. this.logTraceAfterSampling = false; this.logNetworkAfterSampling = false; // TTL of config retrieved from remote config in hours. this.configTimeToLive = 12; } getFlTransportFullUrl() { return this.flTransportEndpointUrl.concat('?key=', this.transportKey); } static getInstance() { if (settingsServiceInstance === undefined) { settingsServiceInstance = new SettingsService(); } return settingsServiceInstance; } } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ var VisibilityState; (function (VisibilityState) { VisibilityState[VisibilityState["UNKNOWN"] = 0] = "UNKNOWN"; VisibilityState[VisibilityState["VISIBLE"] = 1] = "VISIBLE"; VisibilityState[VisibilityState["HIDDEN"] = 2] = "HIDDEN"; })(VisibilityState || (VisibilityState = {})); const RESERVED_ATTRIBUTE_PREFIXES = ['firebase_', 'google_', 'ga_']; const ATTRIBUTE_FORMAT_REGEX = new RegExp('^[a-zA-Z]\\w*$'); const MAX_ATTRIBUTE_NAME_LENGTH = 40; const MAX_ATTRIBUTE_VALUE_LENGTH = 100; function getServiceWorkerStatus() { const navigator = Api.getInstance().navigator; if (navigator === null || navigator === void 0 ? void 0 : navigator.serviceWorker) { if (navigator.serviceWorker.controller) { return 2 /* ServiceWorkerStatus.CONTROLLED */ ; } else { return 3 /* ServiceWorkerStatus.UNCONTROLLED */ ; } } else { return 1 /* ServiceWorkerStatus.UNSUPPORTED */ ; } } function getVisibilityState() { const document = Api.getInstance().document; const visibilityState = document.visibilityState; switch (visibilityState) { case 'visible': return VisibilityState.VISIBLE; case 'hidden': return VisibilityState.HIDDEN; default: return VisibilityState.UNKNOWN; } } function getEffectiveConnectionType() { const navigator = Api.getInstance().navigator; const navigatorConnection = navigator.connection; const effectiveType = navigatorConnection && navigatorConnection.effectiveType; switch (effectiveType) { case 'slow-2g': return 1 /* EffectiveConnectionType.CONNECTION_SLOW_2G */ ; case '2g': return 2 /* EffectiveConnectionType.CONNECTION_2G */ ; case '3g': return 3 /* EffectiveConnectionType.CONNECTION_3G */ ; case '4g': return 4 /* EffectiveConnectionType.CONNECTION_4G */ ; default: return 0 /* EffectiveConnectionType.UNKNOWN */ ; } } function isValidCustomAttributeName(name) { if (name.length === 0 || name.length > MAX_ATTRIBUTE_NAME_LENGTH) { return false; } const matchesReservedPrefix = RESERVED_ATTRIBUTE_PREFIXES.some(prefix => name.startsWith(prefix)); return !matchesReservedPrefix && !!name.match(ATTRIBUTE_FORMAT_REGEX); } function isValidCustomAttributeValue(value) { return value.length !== 0 && value.length <= MAX_ATTRIBUTE_VALUE_LENGTH; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function getAppId(firebaseApp) { var _a; const appId = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.appId; if (!appId) { throw ERROR_FACTORY.create("no app id" /* ErrorCode.NO_APP_ID */ ); } return appId; } function getProjectId(firebaseApp) { var _a; const projectId = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.projectId; if (!projectId) { throw ERROR_FACTORY.create("no project id" /* ErrorCode.NO_PROJECT_ID */ ); } return projectId; } function getApiKey(firebaseApp) { var _a; const apiKey = (_a = firebaseApp.options) === null || _a === void 0 ? void 0 : _a.apiKey; if (!apiKey) { throw ERROR_FACTORY.create("no api key" /* ErrorCode.NO_API_KEY */ ); } return apiKey; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const REMOTE_CONFIG_SDK_VERSION = '0.0.1'; // These values will be used if the remote config object is successfully // retrieved, but the template does not have these fields. const DEFAULT_CONFIGS = { loggingEnabled: true }; const FIS_AUTH_PREFIX = 'FIREBASE_INSTALLATIONS_AUTH'; function getConfig(performanceController, iid) { const config = getStoredConfig(); if (config) { processConfig(config); return Promise.resolve(); } return getRemoteConfig(performanceController, iid).then(processConfig).then(config => storeConfig(config), /** Do nothing for error, use defaults set in settings service. */ () => {}); } function getStoredConfig() { const localStorage = Api.getInstance().localStorage; if (!localStorage) { return; } const expiryString = localStorage.getItem(CONFIG_EXPIRY_LOCAL_STORAGE_KEY); if (!expiryString || !configValid(expiryString)) { return; } const configStringified = localStorage.getItem(CONFIG_LOCAL_STORAGE_KEY); if (!configStringified) { return; } try { const configResponse = JSON.parse(configStringified); return configResponse; } catch (_a) { return; } } function storeConfig(config) { const localStorage = Api.getInstance().localStorage; if (!config || !localStorage) { return; } localStorage.setItem(CONFIG_LOCAL_STORAGE_KEY, JSON.stringify(config)); localStorage.setItem(CONFIG_EXPIRY_LOCAL_STORAGE_KEY, String(Date.now() + SettingsService.getInstance().configTimeToLive * 60 * 60 * 1000)); } const COULD_NOT_GET_CONFIG_MSG = 'Could not fetch config, will use default configs'; function getRemoteConfig(performanceController, iid) { // Perf needs auth token only to retrieve remote config. return getAuthTokenPromise(performanceController.installations).then(authToken => { const projectId = getProjectId(performanceController.app); const apiKey = getApiKey(performanceController.app); const configEndPoint = `https://firebaseremoteconfig.googleapis.com/v1/projects/${projectId}/namespaces/fireperf:fetch?key=${apiKey}`; const request = new Request(configEndPoint, { method: 'POST', headers: { Authorization: `${FIS_AUTH_PREFIX} ${authToken}` }, /* eslint-disable camelcase */ body: JSON.stringify({ app_instance_id: iid, app_instance_id_token: authToken, app_id: getAppId(performanceController.app), app_version: SDK_VERSION, sdk_version: REMOTE_CONFIG_SDK_VERSION }) /* eslint-enable camelcase */ }); return fetch(request).then(response => { if (response.ok) { return response.json(); } // In case response is not ok. This will be caught by catch. throw ERROR_FACTORY.create("RC response not ok" /* ErrorCode.RC_NOT_OK */ ); }); }).catch(() => { consoleLogger.info(COULD_NOT_GET_CONFIG_MSG); return undefined; }); } /** * Processes config coming either from calling RC or from local storage. * This method only runs if call is successful or config in storage * is valid. */ function processConfig(config) { if (!config) { return config; } const settingsServiceInstance = SettingsService.getInstance(); const entries = config.entries || {}; if (entries.fpr_enabled !== undefined) { // TODO: Change the assignment of loggingEnabled once the received type is // known. settingsServiceInstance.loggingEnabled = String(entries.fpr_enabled) === 'true'; } else { // Config retrieved successfully, but there is no fpr_enabled in template. // Use secondary configs value. settingsServiceInstance.loggingEnabled = DEFAULT_CONFIGS.loggingEnabled; } if (entries.fpr_log_source) { settingsServiceInstance.logSource = Number(entries.fpr_log_source); } else if (DEFAULT_CONFIGS.logSource) { settingsServiceInstance.logSource = DEFAULT_CONFIGS.logSource; } if (entries.fpr_log_endpoint_url) { settingsServiceInstance.logEndPointUrl = entries.fpr_log_endpoint_url; } else if (DEFAULT_CONFIGS.logEndPointUrl) { settingsServiceInstance.logEndPointUrl = DEFAULT_CONFIGS.logEndPointUrl; } // Key from Remote Config has to be non-empty string, otherwise use local value. if (entries.fpr_log_transport_key) { settingsServiceInstance.transportKey = entries.fpr_log_transport_key; } else if (DEFAULT_CONFIGS.transportKey) { settingsServiceInstance.transportKey = DEFAULT_CONFIGS.transportKey; } if (entries.fpr_vc_network_request_sampling_rate !== undefined) { settingsServiceInstance.networkRequestsSamplingRate = Number(entries.fpr_vc_network_request_sampling_rate); } else if (DEFAULT_CONFIGS.networkRequestsSamplingRate !== undefined) { settingsServiceInstance.networkRequestsSamplingRate = DEFAULT_CONFIGS.networkRequestsSamplingRate; } if (entries.fpr_vc_trace_sampling_rate !== undefined) { settingsServiceInstance.tracesSamplingRate = Number(entries.fpr_vc_trace_sampling_rate); } else if (DEFAULT_CONFIGS.tracesSamplingRate !== undefined) { settingsServiceInstance.tracesSamplingRate = DEFAULT_CONFIGS.tracesSamplingRate; } // Set the per session trace and network logging flags. settingsServiceInstance.logTraceAfterSampling = shouldLogAfterSampling(settingsServiceInstance.tracesSamplingRate); settingsServiceInstance.logNetworkAfterSampling = shouldLogAfterSampling(settingsServiceInstance.networkRequestsSamplingRate); return config; } function configValid(expiry) { return Number(expiry) > Date.now(); } function shouldLogAfterSampling(samplingRate) { return Math.random() <= samplingRate; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ let initializationStatus = 1 /* InitializationStatus.notInitialized */ ; let initializationPromise; function getInitializationPromise(performanceController) { initializationStatus = 2 /* InitializationStatus.initializationPending */ ; initializationPromise = initializationPromise || initializePerf(performanceController); return initializationPromise; } function isPerfInitialized() { return initializationStatus === 3 /* InitializationStatus.initialized */ ; } function initializePerf(performanceController) { return getDocumentReadyComplete().then(() => getIidPromise(performanceController.installations)).then(iid => getConfig(performanceController, iid)).then(() => changeInitializationStatus(), () => changeInitializationStatus()); } /** * Returns a promise which resolves whenever the document readystate is complete or * immediately if it is called after page load complete. */ function getDocumentReadyComplete() { const document = Api.getInstance().document; return new Promise(resolve => { if (document && document.readyState !== 'complete') { const handler = () => { if (document.readyState === 'complete') { document.removeEventListener('readystatechange', handler); resolve(); } }; document.addEventListener('readystatechange', handler); } else { resolve(); } }); } function changeInitializationStatus() { initializationStatus = 3 /* InitializationStatus.initialized */ ; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const DEFAULT_SEND_INTERVAL_MS = 10 * 1000; const INITIAL_SEND_TIME_DELAY_MS = 5.5 * 1000; const MAX_EVENT_COUNT_PER_REQUEST = 1000; const DEFAULT_REMAINING_TRIES = 3; let remainingTries = DEFAULT_REMAINING_TRIES; /* eslint-enable camelcase */ let queue = []; let isTransportSetup = false; function setupTransportService() { if (!isTransportSetup) { processQueue(INITIAL_SEND_TIME_DELAY_MS); isTransportSetup = true; } } function processQueue(timeOffset) { setTimeout(() => { // If there is no remainingTries left, stop retrying. if (remainingTries <= 0) { return; } if (queue.length > 0) { dispatchQueueEvents(); } processQueue(DEFAULT_SEND_INTERVAL_MS); }, timeOffset); } function dispatchQueueEvents() { // Extract events up to the maximum cap of single logRequest from top of "official queue". // The staged events will be used for current logRequest attempt, remaining events will be kept // for next attempt. const staged = queue.splice(0, MAX_EVENT_COUNT_PER_REQUEST); /* eslint-disable camelcase */ // We will pass the JSON serialized event to the backend. const log_event = staged.map(evt => ({ source_extension_json_proto3: evt.message, event_time_ms: String(evt.eventTime) })); const data = { request_time_ms: String(Date.now()), client_info: { client_type: 1, // 1 is JS js_client_info: {} }, log_source: SettingsService.getInstance().logSource, log_event }; /* eslint-enable camelcase */ postToFlEndpoint(data).then(() => { remainingTries = DEFAULT_REMAINING_TRIES; }).catch(() => { // If the request fails for some reason, add the events that were attempted // back to the primary queue to retry later. queue = [...staged, ...queue]; remainingTries--; consoleLogger.info(`Tries left: ${remainingTries}.`); processQueue(DEFAULT_SEND_INTERVAL_MS); }); } function postToFlEndpoint(data) { const flTransportFullUrl = SettingsService.getInstance().getFlTransportFullUrl(); const body = JSON.stringify(data); return navigator.sendBeacon && navigator.sendBeacon(flTransportFullUrl, body) ? Promise.resolve() : fetch(flTransportFullUrl, { method: 'POST', body, keepalive: true }).then(); } function addToQueue(evt) { if (!evt.eventTime || !evt.message) { throw ERROR_FACTORY.create("invalid cc log" /* ErrorCode.INVALID_CC_LOG */ ); } // Add the new event to the queue. queue = [...queue, evt]; } /** Log handler for cc service to send the performance logs to the server. */ function transportHandler( // eslint-disable-next-line @typescript-eslint/no-explicit-any serializer) { return (...args) => { const message = serializer(...args); addToQueue({ message, eventTime: Date.now() }); }; } /** * Force flush the queued events. Useful at page unload time to ensure all * events are uploaded. */ function flushQueuedEvents() { while (queue.length > 0) { dispatchQueueEvents(); } } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ let logger; // // This method is not called before initialization. function sendLog(resource, resourceType) { if (!logger) { logger = { send: transportHandler(serializer), flush: flushQueuedEvents }; } logger.send(resource, resourceType); } function logTrace(trace) { const settingsService = SettingsService.getInstance(); // Do not log if trace is auto generated and instrumentation is disabled. if (!settingsService.instrumentationEnabled && trace.isAuto) { return; } // Do not log if trace is custom and data collection is disabled. if (!settingsService.dataCollectionEnabled && !trace.isAuto) { return; } // Do not log if required apis are not available. if (!Api.getInstance().requiredApisAvailable()) { return; } if (isPerfInitialized()) { sendTraceLog(trace); } else { // Custom traces can be used before the initialization but logging // should wait until after. getInitializationPromise(trace.performanceController).then(() => sendTraceLog(trace), () => sendTraceLog(trace)); } } function flushLogs() { if (logger) { logger.flush(); } } function sendTraceLog(trace) { if (!getIid()) { return; } const settingsService = SettingsService.getInstance(); if (!settingsService.loggingEnabled || !settingsService.logTraceAfterSampling) { return; } sendLog(trace, 1 /* ResourceType.Trace */ ); } function logNetworkRequest(networkRequest) { const settingsService = SettingsService.getInstance(); // Do not log network requests if instrumentation is disabled. if (!settingsService.instrumentationEnabled) { return; } // Do not log the js sdk's call to transport service domain to avoid unnecessary cycle. // Need to blacklist both old and new endpoints to avoid migration gap. const networkRequestUrl = networkRequest.url; // Blacklist old log endpoint and new transport endpoint. // Because Performance SDK doesn't instrument requests sent from SDK itself. const logEndpointUrl = settingsService.logEndPointUrl.split('?')[0]; const flEndpointUrl = settingsService.flTransportEndpointUrl.split('?')[0]; if (networkRequestUrl === logEndpointUrl || networkRequestUrl === flEndpointUrl) { return; } if (!settingsService.loggingEnabled || !settingsService.logNetworkAfterSampling) { return; } sendLog(networkRequest, 0 /* ResourceType.NetworkRequest */ ); } function serializer(resource, resourceType) { if (resourceType === 0 /* ResourceType.NetworkRequest */ ) { return serializeNetworkRequest(resource); } return serializeTrace(resource); } function serializeNetworkRequest(networkRequest) { const networkRequestMetric = { url: networkRequest.url, http_method: networkRequest.httpMethod || 0, http_response_code: 200, response_payload_bytes: networkRequest.responsePayloadBytes, client_start_time_us: networkRequest.startTimeUs, time_to_response_initiated_us: networkRequest.timeToResponseInitiatedUs, time_to_response_completed_us: networkRequest.timeToResponseCompletedUs }; const perfMetric = { application_info: getApplicationInfo(networkRequest.performanceController.app), network_request_metric: networkRequestMetric }; return JSON.stringify(perfMetric); } function serializeTrace(trace) { const traceMetric = { name: trace.name, is_auto: trace.isAuto, client_start_time_us: trace.startTimeUs, duration_us: trace.durationUs }; if (Object.keys(trace.counters).length !== 0) { traceMetric.counters = trace.counters; } const customAttributes = trace.getAttributes(); if (Object.keys(customAttributes).length !== 0) { traceMetric.custom_attributes = customAttributes; } const perfMetric = { application_info: getApplicationInfo(trace.performanceController.app), trace_metric: traceMetric }; return JSON.stringify(perfMetric); } function getApplicationInfo(firebaseApp) { return { google_app_id: getAppId(firebaseApp), app_instance_id: getIid(), web_app_info: { sdk_version: SDK_VERSION, page_url: Api.getInstance().getUrl(), service_worker_status: getServiceWorkerStatus(), visibility_state: getVisibilityState(), effective_connection_type: getEffectiveConnectionType() }, application_process_state: 0 }; } /* eslint-enable camelcase */ /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ function createNetworkRequestEntry(performanceController, entry) { const performanceEntry = entry; if (!performanceEntry || performanceEntry.responseStart === undefined) { return; } const timeOrigin = Api.getInstance().getTimeOrigin(); const startTimeUs = Math.floor((performanceEntry.startTime + timeOrigin) * 1000); const timeToResponseInitiatedUs = performanceEntry.responseStart ? Math.floor((performanceEntry.responseStart - performanceEntry.startTime) * 1000) : undefined; const timeToResponseCompletedUs = Math.floor((performanceEntry.responseEnd - performanceEntry.startTime) * 1000); // Remove the query params from logged network request url. const url = performanceEntry.name && performanceEntry.name.split('?')[0]; const networkRequest = { performanceController, url, responsePayloadBytes: performanceEntry.transferSize, startTimeUs, timeToResponseInitiatedUs, timeToResponseCompletedUs }; logNetworkRequest(networkRequest); } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ const MAX_METRIC_NAME_LENGTH = 100; const RESERVED_AUTO_PREFIX = '_'; const oobMetrics = [FIRST_PAINT_COUNTER_NAME, FIRST_CONTENTFUL_PAINT_COUNTER_NAME, FIRST_INPUT_DELAY_COUNTER_NAME, LARGEST_CONTENTFUL_PAINT_METRIC_NAME, CUMULATIVE_LAYOUT_SHIFT_METRIC_NAME, INTERACTION_TO_NEXT_PAINT_METRIC_NAME]; /** * Returns true if the metric is custom and does not start with reserved prefix, or if * the metric is one of out of the box page load trace metrics. */ function isValidMetricName(name, traceName) { if (name.length === 0 || name.length > MAX_METRIC_NAME_LENGTH) { return false; } return traceName && traceName.startsWith(OOB_TRACE_PAGE_LOAD_PREFIX) && oobMetrics.indexOf(name) > -1 || !name.startsWith(RESERVED_AUTO_PREFIX); } /** * Converts the provided value to an integer value to be used in case of a metric. * @param providedValue Provided number value of the metric that needs to be converted to an integer. * * @returns Converted integer number to be set for the metric. */ function convertMetricValueToInteger(providedValue) { const valueAsInteger = Math.floor(providedValue); if (valueAsInteger < providedValue) { consoleLogger.info(`Metric value should be an Integer, setting the value as : ${valueAsInteger}.`); } return valueAsInteger; } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ class Trace { /** * @param performanceController The performance controller running. * @param name The name of the trace. * @param isAuto If the trace is auto-instrumented. * @param traceMeasureName The name of the measure marker in user timing specification. This field * is only set when the trace is built for logging when the user directly uses the user timing * api (performance.mark and performance.measure). */ constructor(performanceController, name, isAuto = false, traceMeasureName) { this.performanceController = performanceController; this.name = name; this.isAuto = isAuto; this.state = 1 /* TraceState.UNINITIALIZED */ ; this.customAttributes = {}; this.counters = {}; this.api = Api.getInstance(); this.randomId = Math.floor(Math.random() * 1000000); if (!this.isAuto) { this.traceStartMark = `${TRACE_START_MARK_PREFIX}-${this.randomId}-${this.name}`; this.traceStopMark = `${TRACE_STOP_MARK_PREFIX}-${this.randomId}-${this.name}`; this.traceMeasure = traceMeasureName || `${TRACE_MEASURE_PREFIX}-${this.randomId}-${this.name}`; if (traceMeasureName) { // For the case of direct user timing traces, no start stop will happen. The measure object // is already available. this.calculateTraceMetrics(); } } } /** * Starts a trace. The measurement of the duration starts at this point. */ start() { if (this.state !== 1 /* TraceState.UNINITIALIZED */ ) { throw ERROR_FACTORY.create("trace started" /* ErrorCode.TRACE_STARTED_BEFORE */ , { traceName: this.name }); } this.api.mark(this.traceStartMark); this.state = 2 /* TraceState.RUNNING */ ; } /** * Stops the trace. The measurement of the duration of the trace stops at this point and trace * is logged. */ stop() { if (this.state !== 2 /* TraceState.RUNNING */ ) { throw ERROR_FACTORY.create("trace stopped" /* ErrorCode.TRACE_STOPPED_BEFORE */ , { traceName: this.name }); } this.state = 3 /* TraceState.TERMINATED */ ; this.api.mark(this.traceStopMark); this.api.measure(this.traceMeasure, this.traceStartMark, this.traceStopMark); this.calculateTraceMetrics(); logTrace(this); } /** * Records a trace with predetermined values. If this method is used a trace is created and logged * directly. No need to use start and stop methods. * @param startTime Trace start time since epoch in millisec * @param duration The duration of the trace in millisec * @param options An object which can optionally hold maps of custom metrics and custom attributes */ record(startTime, duration, options) { if (startTime <= 0) { throw ERROR_FACTORY.create("nonpositive trace startTime" /* ErrorCode.NONPOSITIVE_TRACE_START_TIME */ , { traceName: this.name }); } if (duration <= 0) { throw ERROR_FACTORY.create("nonpositive trace duration" /* ErrorCode.NONPOSITIVE_TRACE_DURATION */ , { traceName: this.name }); } this.durationUs = Math.floor(duration * 1000); this.startTimeUs = Math.floor(startTime * 1000); if (options && options.attributes) { this.customAttributes = Object.assign({}, options.attributes); } if (options && options.metrics) { for (const metricName of Object.keys(options.metrics)) { if (!isNaN(Number(options.metrics[metricName]))) { this.counters[metricName] = Math.floor(Number(options.metrics[metricName])); } } } logTrace(this); } /** * Increments a custom metric by a certain number or 1 if number not specified. Will create a new * custom metric if one with the given name does not exist. The value will be floored down to an * integer. * @param counter Name of the custom metric * @param numAsInteger Increment by value */ incrementMetric(counter, numAsInteger = 1) { if (this.counters[counter] === undefined) { this.putMetric(counter, numAsInteger); } else { this.putMetric(counter, this.counters[counter] + numAsInteger); } } /** * Sets a custom metric to a specified value. Will create a new custom metric if one with the * given name does not exist. The value will be floored down to an integer. * @param counter Name of the custom metric * @param numAsInteger Set custom metric to this value */ putMetric(counter, numAsInteger) { if (isValidMetricName(counter, this.name)) { this.counters[counter] = convertMetricValueToInteger(numAsInteger !== null && numAsInteger !== void 0 ? numAsInteger : 0); } else { throw ERROR_FACTORY.create("invalid custom metric name" /* ErrorCode.INVALID_CUSTOM_METRIC_NAME */ , { customMetricName: counter }); } } /** * Returns the value of the custom metric by that name. If a custom metric with that name does * not exist will return zero. * @param counter */ getMetric(counter) { return this.counters[counter] || 0; } /** * Sets a custom attribute of a trace to a certain value. * @param attr * @param value */ putAttribute(attr, value) { const isValidName = isValidCustomAttributeName(attr); const isValidValue = isValidCustomAttributeValue(value); if (isValidName && isValidValue) { this.customAttributes[attr] = value; return; } // Throw appropriate error when the attribute name or value is invalid. if (!isValidName) { throw ERROR_FACTORY.create("invalid attribute name" /* ErrorCode.INVALID_ATTRIBUTE_NAME */ , { attributeName: attr }); } if (!isValidValue) { throw ERROR_FACTORY.create("invalid attribute value" /* ErrorCode.INVALID_ATTRIBUTE_VALUE */ , { attributeValue: value }); } } /** * Retrieves the value a custom attribute of a trace is set to. * @param attr */ getAttribute(attr) { return this.customAttributes[attr]; } removeAttribute(attr) { if (this.customAttributes[attr] === undefined) { return; } delete this.customAttributes[attr]; } getAttributes() { return Object.assign({}, this.customAttributes); } setStartTime(startTime) { this.startTimeUs = startTime; } setDuration(duration) { this.durationUs = duration; } /** * Calculates and assigns the duration and start time of the trace using the measure performance * entry. */ calculateTraceMetrics() { const perfMeasureEntries = this.api.getEntriesByName(this.traceMeasure); const perfMeasureEntry = perfMeasureEntries && perfMeasureEntries[0]; if (perfMeasureEntry) { this.durationUs = Math.floor(perfMeasureEntry.duration * 1000); this.startTimeUs = Math.floor((perfMeasureEntry.startTime + this.api.getTimeOrigin()) * 1000); } } /** * @param navigationTimings A single element array which contains the navigationTIming object of * the page load * @param paintTimings A array which contains paintTiming object of the page load * @param firstInputDelay First input delay in millisec */ static createOobTrace(performanceController, navigationTimings, paintTimings, webVitalMetrics, firstInputDelay) { const route = Api.getInstance().getUrl(); if (!route) { return; } const trace = new Trace(performanceController, OOB_TRACE_PAGE_LOAD_PREFIX + route, true); const timeOriginUs = Math.floor(Api.getInstance().getTimeOrigin() * 1000); trace.setStartTime(timeOriginUs); // navigationTimings includes only one element. if (navigationTimings && navigationTimings[0]) { trace.setDuration(Math.floor(navigationTimings[0].duration * 1000)); trace.putMetric('domInteractive', Math.floor(navigationTimings[0].domInteractive * 1000)); trace.putMetric('domContentLoadedEventEnd', Math.floor(navigationTimings[0].domContentLoadedEventEnd * 1000)); trace.putMetric('loadEventEnd', Math.floor(navigationTimings[0].loadEventEnd * 1000)); } const FIRST_PAINT = 'first-paint'; const FIRST_CONTENTFUL_PAINT = 'first-contentful-paint'; if (paintTimings) { const firstPaint = paintTimings.find(paintObject => paintObject.name === FIRST_PAINT); if (firstPaint && firstPaint.startTime) { trace.putMetric(FIRST_PAINT_COUNTER_NAME, Math.floor(firstPaint.startTime * 1000)); } const firstContentfulPaint = paintTimings.find(paintObject => paintObject.name === FIRST_CONTENTFUL_PAINT); if (firstContentfulPaint && firstContentfulPaint.startTime) { trace.putMetric(FIRST_CONTENTFUL_PAINT_COUNTER_NAME, Math.floor(firstContentfulPaint.startTime * 1000)); } if (firstInputDelay) { trace.putMetric(FIRST_INPUT_DELAY_COUNTER_NAME, Math.floor(firstInputDelay * 1000)); } } this.addWebVitalMetric(trace, LARGEST_CONTENTFUL_PAINT_METRIC_NAME, LARGEST_CONTENTFUL_PAINT_ATTRIBUTE_NAME, webVitalMetrics.lcp); this.addWebVitalMetric(trace, CUMULATIVE_LAYOUT_SHIFT_METRIC_NAME, CUMULATIVE_LAYOUT_SHIFT_ATTRIBUTE_NAME, webVitalMetrics.cls); this.addWebVitalMetric(trace, INTERACTION_TO_NEXT_PAINT_METRIC_NAME, INTERACTION_TO_NEXT_PAINT_ATTRIBUTE_NAME, webVitalMetrics.inp); // Page load logs are sent at unload time and so should be logged and // flushed immediately. logTrace(trace); flushLogs(); } static addWebVitalMetric(trace, metricKey, attributeKey, metric) { if (metric) { trace.putMetric(metricKey, Math.floor(metric.value * 1000)); if (metric.elementAttribution) { trace.putAttribute(attributeKey, metric.elementAttribution); } } } static createUserTimingTrace(performanceController, measureName) { const trace = new Trace(performanceController, measureName, false, measureName); logTrace(trace); } } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ let webVitalMetrics = {}; let sentPageLoadTrace = false; let firstInputDelay; function setupOobResources(performanceController) { // Do not initialize unless iid is available. if (!getIid()) { return; } // The load event might not have fired yet, and that means performance // navigation timing object has a duration of 0. The setup should run after // all current tasks in js queue. setTimeout(() => setupOobTraces(performanceController), 0); setTimeout(() => setupNetworkRequests(performanceController), 0); setTimeout(() => setupUserTimingTraces(performanceController), 0); } function setupNetworkRequests(performanceController) { const api = Api.getInstance(); const resources = api.getEntriesByType('resource'); for (const resource of resources) { createNetworkRequestEntry(performanceController, resource); } api.setupObserver('resource', entry => createNetworkRequestEntry(performanceController, entry)); } function setupOobTraces(performanceController) { const api = Api.getInstance(); // Better support for Safari if ('onpagehide' in window) { api.document.addEventListener('pagehide', () => sendOobTrace(performanceController)); } else { api.document.addEventListener('unload', () => sendOobTrace(performanceController)); } api.document.addEventListener('visibilitychange', () => { if (api.document.visibilityState === 'hidden') { sendOobTrace(performanceController); } }); if (api.onFirstInputDelay) { api.onFirstInputDelay(fid => { firstInputDelay = fid; }); } api.onLCP(metric => { var _a; webVitalMetrics.lcp = { value: metric.value, elementAttribution: (_a = metric.attribution) === null || _a === void 0 ? void 0 : _a.element }; }); api.onCLS(metric => { var _a; webVitalMetrics.cls = { value: metric.value, elementAttribution: (_a = metric.attribution) === null || _a === void 0 ? void 0 : _a.largestShiftTarget }; }); api.onINP(metric => { var _a; webVitalMetrics.inp = { value: metric.value, elementAttribution: (_a = metric.attribution) === null || _a === void 0 ? void 0 : _a.interactionTarget }; }); } function setupUserTimingTraces(performanceController) { const api = Api.getInstance(); // Run through the measure performance entries collected up to this point. const measures = api.getEntriesByType('measure'); for (const measure of measures) { createUserTimingTrace(performanceController, measure); } // Setup an observer to capture the measures from this point on. api.setupObserver('measure', entry => createUserTimingTrace(performanceController, entry)); } function createUserTimingTrace(performanceController, measure) { const measureName = measure.name; // Do not create a trace, if the user timing marks and measures are created by // the sdk itself. if (measureName.substring(0, TRACE_MEASURE_PREFIX.length) === TRACE_MEASURE_PREFIX) { return; } Trace.createUserTimingTrace(performanceController, measureName); } function sendOobTrace(performanceController) { if (!sentPageLoadTrace) { sentPageLoadTrace = true; const api = Api.getInstance(); const navigationTimings = api.getEntriesByType('navigation'); const paintTimings = api.getEntriesByType('paint'); // On page unload web vitals may be updated so queue the oob trace creation // so that these updates have time to be included. setTimeout(() => { Trace.createOobTrace(performanceController, navigationTimings, paintTimings, webVitalMetrics, firstInputDelay); }, 0); } } /** * @license * Copyright 2020 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ class PerformanceController { constructor(app, installations) { this.app = app; this.installations = installations; this.initialized = false; } /** * This method *must* be called internally as part of creating a * PerformanceController instance. * * Currently it's not possible to pass the settings object through the * constructor using Components, so this method exists to be called with the * desired settings, to ensure nothing is collected without the user's * consent. */ _init(settings) { if (this.initialized) { return; } if ((settings === null || settings === void 0 ? void 0 : settings.dataCollectionEnabled) !== undefined) { this.dataCollectionEnabled = settings.dataCollectionEnabled; } if ((settings === null || settings === void 0 ? void 0 : settings.instrumentationEnabled) !== undefined) { this.instrumentationEnabled = settings.instrumentationEnabled; } if (Api.getInstance().requiredApisAvailable()) { (0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.validateIndexedDBOpenable)().then(isAvailable => { if (isAvailable) { setupTransportService(); getInitializationPromise(this).then(() => setupOobResources(this), () => setupOobResources(this)); this.initialized = true; } }).catch(error => { consoleLogger.info(`Environment doesn't support IndexedDB: ${error}`); }); } else { consoleLogger.info('Firebase Performance cannot start if the browser does not support ' + '"Fetch" and "Promise", or cookies are disabled.'); } } set instrumentationEnabled(val) { SettingsService.getInstance().instrumentationEnabled = val; } get instrumentationEnabled() { return SettingsService.getInstance().instrumentationEnabled; } set dataCollectionEnabled(val) { SettingsService.getInstance().dataCollectionEnabled = val; } get dataCollectionEnabled() { return SettingsService.getInstance().dataCollectionEnabled; } } /** * The Firebase Performance Monitoring Web SDK. * This SDK does not work in a Node.js environment. * * @packageDocumentation */ const DEFAULT_ENTRY_NAME = '[DEFAULT]'; /** * Returns a {@link FirebasePerformance} instance for the given app. * @param app - The {@link @firebase/app#FirebaseApp} to use. * @public */ function getPerformance(app = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_3__.getApp)()) { app = (0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.getModularInstance)(app); const provider = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_3__._getProvider)(app, 'performance'); const perfInstance = provider.getImmediate(); return perfInstance; } /** * Returns a {@link FirebasePerformance} instance for the given app. Can only be called once. * @param app - The {@link @firebase/app#FirebaseApp} to use. * @param settings - Optional settings for the {@link FirebasePerformance} instance. * @public */ function initializePerformance(app, settings) { app = (0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.getModularInstance)(app); const provider = (0,_firebase_app__WEBPACK_IMPORTED_MODULE_3__._getProvider)(app, 'performance'); // throw if an instance was already created. // It could happen if initializePerformance() is called more than once, or getPerformance() is called first. if (provider.isInitialized()) { const existingInstance = provider.getImmediate(); const initialSettings = provider.getOptions(); if ((0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.deepEqual)(initialSettings, settings !== null && settings !== void 0 ? settings : {})) { return existingInstance; } else { throw ERROR_FACTORY.create("already initialized" /* ErrorCode.ALREADY_INITIALIZED */ ); } } const perfInstance = provider.initialize({ options: settings }); return perfInstance; } /** * Returns a new `PerformanceTrace` instance. * @param performance - The {@link FirebasePerformance} instance to use. * @param name - The name of the trace. * @public */ function trace(performance, name) { performance = (0,_firebase_util__WEBPACK_IMPORTED_MODULE_0__.getModularInstance)(performance); return new Trace(performance, name); } const factory = (container, { options: settings }) => { // Dependencies const app = container.getProvider('app').getImmediate(); const installations = container.getProvider('installations-internal').getImmediate(); if (app.name !== DEFAULT_ENTRY_NAME) { throw ERROR_FACTORY.create("FB not default" /* ErrorCode.FB_NOT_DEFAULT */ ); } if (typeof window === 'undefined') { throw ERROR_FACTORY.create("no window" /* ErrorCode.NO_WINDOW */ ); } setupApi(window); const perfInstance = new PerformanceController(app, installations); perfInstance._init(settings); return perfInstance; }; function registerPerformance() { (0,_firebase_app__WEBPACK_IMPORTED_MODULE_3__._registerComponent)(new _firebase_component__WEBPACK_IMPORTED_MODULE_4__.Component('performance', factory, "PUBLIC" /* ComponentType.PUBLIC */ )); (0,_firebase_app__WEBPACK_IMPORTED_MODULE_3__.registerVersion)(name, version); // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation (0,_firebase_app__WEBPACK_IMPORTED_MODULE_3__.registerVersion)(name, version, 'esm2017'); } registerPerformance(); /***/ }), /***/ 70503: /*!********************************************************************************!*\ !*** ./node_modules/firebase/node_modules/@firebase/util/dist/postinstall.mjs ***! \********************************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "getDefaultsFromPostinstall": () => (/* binding */ getDefaultsFromPostinstall) /* harmony export */ }); const getDefaultsFromPostinstall = () => undefined; /***/ }), /***/ 69662: /*!*****************************************************************!*\ !*** ./node_modules/firebase/performance/dist/esm/index.esm.js ***! \*****************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "getPerformance": () => (/* reexport safe */ _firebase_performance__WEBPACK_IMPORTED_MODULE_0__.getPerformance), /* harmony export */ "initializePerformance": () => (/* reexport safe */ _firebase_performance__WEBPACK_IMPORTED_MODULE_0__.initializePerformance), /* harmony export */ "trace": () => (/* reexport safe */ _firebase_performance__WEBPACK_IMPORTED_MODULE_0__.trace) /* harmony export */ }); /* harmony import */ var _firebase_performance__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @firebase/performance */ 87823); /***/ }), /***/ 60818: /*!*****************************************!*\ !*** ./node_modules/idb/build/index.js ***! \*****************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "deleteDB": () => (/* binding */ deleteDB), /* harmony export */ "openDB": () => (/* binding */ openDB), /* harmony export */ "unwrap": () => (/* reexport safe */ _wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.u), /* harmony export */ "wrap": () => (/* reexport safe */ _wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.w) /* harmony export */ }); /* harmony import */ var _Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js */ 71670); /* harmony import */ var _wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./wrap-idb-value.js */ 47129); /** * Open a database. * * @param name Name of the database. * @param version Schema version. * @param callbacks Additional callbacks. */ function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) { const request = indexedDB.open(name, version); const openPromise = (0,_wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.w)(request); if (upgrade) { request.addEventListener('upgradeneeded', event => { upgrade((0,_wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.w)(request.result), event.oldVersion, event.newVersion, (0,_wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.w)(request.transaction), event); }); } if (blocked) { request.addEventListener('blocked', event => blocked( // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405 event.oldVersion, event.newVersion, event)); } openPromise.then(db => { if (terminated) db.addEventListener('close', () => terminated()); if (blocking) { db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event)); } }).catch(() => {}); return openPromise; } /** * Delete a database. * * @param name Name of the database. */ function deleteDB(name, { blocked } = {}) { const request = indexedDB.deleteDatabase(name); if (blocked) { request.addEventListener('blocked', event => blocked( // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405 event.oldVersion, event)); } return (0,_wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.w)(request).then(() => undefined); } const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count']; const writeMethods = ['put', 'add', 'delete', 'clear']; const cachedMethods = new Map(); function getMethod(target, prop) { if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) { return; } if (cachedMethods.get(prop)) return cachedMethods.get(prop); const targetFuncName = prop.replace(/FromIndex$/, ''); const useIndex = prop !== targetFuncName; const isWrite = writeMethods.includes(targetFuncName); if ( // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge. !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) { return; } const method = /*#__PURE__*/function () { var _ref = (0,_Volumes_case_workspace_work_APPS_KA_APP_WORK_NOW_KA_PASS_V2_2_6_node_modules_babel_runtime_helpers_esm_asyncToGenerator_js__WEBPACK_IMPORTED_MODULE_0__["default"])(function* (storeName, ...args) { // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :( const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly'); let target = tx.store; if (useIndex) target = target.index(args.shift()); // Must reject if op rejects. // If it's a write operation, must reject if tx.done rejects. // Must reject with op rejection first. // Must resolve with op value. // Must handle both promises (no unhandled rejections) return (yield Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0]; }); return function method(_x) { return _ref.apply(this, arguments); }; }(); cachedMethods.set(prop, method); return method; } (0,_wrap_idb_value_js__WEBPACK_IMPORTED_MODULE_1__.r)(oldTraps => ({ ...oldTraps, get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver), has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop) })); /***/ }), /***/ 47129: /*!**************************************************!*\ !*** ./node_modules/idb/build/wrap-idb-value.js ***! \**************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "a": () => (/* binding */ reverseTransformCache), /* harmony export */ "i": () => (/* binding */ instanceOfAny), /* harmony export */ "r": () => (/* binding */ replaceTraps), /* harmony export */ "u": () => (/* binding */ unwrap), /* harmony export */ "w": () => (/* binding */ wrap) /* harmony export */ }); const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c); let idbProxyableTypes; let cursorAdvanceMethods; // This is a function to prevent it throwing up in node environments. function getIdbProxyableTypes() { return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]); } // This is a function to prevent it throwing up in node environments. function getCursorAdvanceMethods() { return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]); } const cursorRequestMap = new WeakMap(); const transactionDoneMap = new WeakMap(); const transactionStoreNamesMap = new WeakMap(); const transformCache = new WeakMap(); const reverseTransformCache = new WeakMap(); function promisifyRequest(request) { const promise = new Promise((resolve, reject) => { const unlisten = () => { request.removeEventListener('success', success); request.removeEventListener('error', error); }; const success = () => { resolve(wrap(request.result)); unlisten(); }; const error = () => { reject(request.error); unlisten(); }; request.addEventListener('success', success); request.addEventListener('error', error); }); promise.then(value => { // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval // (see wrapFunction). if (value instanceof IDBCursor) { cursorRequestMap.set(value, request); } // Catching to avoid "Uncaught Promise exceptions" }).catch(() => {}); // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This // is because we create many promises from a single IDBRequest. reverseTransformCache.set(promise, request); return promise; } function cacheDonePromiseForTransaction(tx) { // Early bail if we've already created a done promise for this transaction. if (transactionDoneMap.has(tx)) return; const done = new Promise((resolve, reject) => { const unlisten = () => { tx.removeEventListener('complete', complete); tx.removeEventListener('error', error); tx.removeEventListener('abort', error); }; const complete = () => { resolve(); unlisten(); }; const error = () => { reject(tx.error || new DOMException('AbortError', 'AbortError')); unlisten(); }; tx.addEventListener('complete', complete); tx.addEventListener('error', error); tx.addEventListener('abort', error); }); // Cache it for later retrieval. transactionDoneMap.set(tx, done); } let idbProxyTraps = { get(target, prop, receiver) { if (target instanceof IDBTransaction) { // Special handling for transaction.done. if (prop === 'done') return transactionDoneMap.get(target); // Polyfill for objectStoreNames because of Edge. if (prop === 'objectStoreNames') { return target.objectStoreNames || transactionStoreNamesMap.get(target); } // Make tx.store return the only store in the transaction, or undefined if there are many. if (prop === 'store') { return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]); } } // Else transform whatever we get back. return wrap(target[prop]); }, set(target, prop, value) { target[prop] = value; return true; }, has(target, prop) { if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) { return true; } return prop in target; } }; function replaceTraps(callback) { idbProxyTraps = callback(idbProxyTraps); } function wrapFunction(func) { // Due to expected object equality (which is enforced by the caching in `wrap`), we // only create one new func per func. // Edge doesn't support objectStoreNames (booo), so we polyfill it here. if (func === IDBDatabase.prototype.transaction && !('objectStoreNames' in IDBTransaction.prototype)) { return function (storeNames, ...args) { const tx = func.call(unwrap(this), storeNames, ...args); transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]); return wrap(tx); }; } // Cursor methods are special, as the behaviour is a little more different to standard IDB. In // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense // with real promises, so each advance methods returns a new promise for the cursor object, or // undefined if the end of the cursor has been reached. if (getCursorAdvanceMethods().includes(func)) { return function (...args) { // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use // the original object. func.apply(unwrap(this), args); return wrap(cursorRequestMap.get(this)); }; } return function (...args) { // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use // the original object. return wrap(func.apply(unwrap(this), args)); }; } function transformCachableValue(value) { if (typeof value === 'function') return wrapFunction(value); // This doesn't return, it just creates a 'done' promise for the transaction, // which is later returned for transaction.done (see idbObjectHandler). if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value); if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps); // Return the same value back if we're not going to transform it. return value; } function wrap(value) { // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached. if (value instanceof IDBRequest) return promisifyRequest(value); // If we've already transformed this value before, reuse the transformed value. // This is faster, but it also provides object equality. if (transformCache.has(value)) return transformCache.get(value); const newValue = transformCachableValue(value); // Not all types are transformed. // These may be primitive types, so they can't be WeakMap keys. if (newValue !== value) { transformCache.set(value, newValue); reverseTransformCache.set(newValue, value); } return newValue; } const unwrap = value => reverseTransformCache.get(value); /***/ }), /***/ 471: /*!****************************************************************!*\ !*** ./node_modules/web-vitals/dist/web-vitals.attribution.js ***! \****************************************************************/ /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { /* harmony export */ "CLSThresholds": () => (/* binding */ M), /* harmony export */ "FCPThresholds": () => (/* binding */ L), /* harmony export */ "FIDThresholds": () => (/* binding */ ht), /* harmony export */ "INPThresholds": () => (/* binding */ W), /* harmony export */ "LCPThresholds": () => (/* binding */ it), /* harmony export */ "TTFBThresholds": () => (/* binding */ ct), /* harmony export */ "onCLS": () => (/* binding */ D), /* harmony export */ "onFCP": () => (/* binding */ w), /* harmony export */ "onFID": () => (/* binding */ yt), /* harmony export */ "onINP": () => (/* binding */ rt), /* harmony export */ "onLCP": () => (/* binding */ ot), /* harmony export */ "onTTFB": () => (/* binding */ ft) /* harmony export */ }); var t, e, n = function () { var t = self.performance && performance.getEntriesByType && performance.getEntriesByType("navigation")[0]; if (t && t.responseStart > 0 && t.responseStart < performance.now()) return t; }, r = function (t) { if ("loading" === document.readyState) return "loading"; var e = n(); if (e) { if (t < e.domInteractive) return "loading"; if (0 === e.domContentLoadedEventStart || t < e.domContentLoadedEventStart) return "dom-interactive"; if (0 === e.domComplete || t < e.domComplete) return "dom-content-loaded"; } return "complete"; }, i = function (t) { var e = t.nodeName; return 1 === t.nodeType ? e.toLowerCase() : e.toUpperCase().replace(/^#/, ""); }, a = function (t, e) { var n = ""; try { for (; t && 9 !== t.nodeType;) { var r = t, a = r.id ? "#" + r.id : i(r) + (r.classList && r.classList.value && r.classList.value.trim() && r.classList.value.trim().length ? "." + r.classList.value.trim().replace(/\s+/g, ".") : ""); if (n.length + a.length > (e || 100) - 1) return n || a; if (n = n ? a + ">" + n : a, r.id) break; t = r.parentNode; } } catch (t) {} return n; }, o = -1, c = function () { return o; }, u = function (t) { addEventListener("pageshow", function (e) { e.persisted && (o = e.timeStamp, t(e)); }, !0); }, s = function () { var t = n(); return t && t.activationStart || 0; }, f = function (t, e) { var r = n(), i = "navigate"; c() >= 0 ? i = "back-forward-cache" : r && (document.prerendering || s() > 0 ? i = "prerender" : document.wasDiscarded ? i = "restore" : r.type && (i = r.type.replace(/_/g, "-"))); return { name: t, value: void 0 === e ? -1 : e, rating: "good", delta: 0, entries: [], id: "v4-".concat(Date.now(), "-").concat(Math.floor(8999999999999 * Math.random()) + 1e12), navigationType: i }; }, d = function (t, e, n) { try { if (PerformanceObserver.supportedEntryTypes.includes(t)) { var r = new PerformanceObserver(function (t) { Promise.resolve().then(function () { e(t.getEntries()); }); }); return r.observe(Object.assign({ type: t, buffered: !0 }, n || {})), r; } } catch (t) {} }, l = function (t, e, n, r) { var i, a; return function (o) { e.value >= 0 && (o || r) && ((a = e.value - (i || 0)) || void 0 === i) && (i = e.value, e.delta = a, e.rating = function (t, e) { return t > e[1] ? "poor" : t > e[0] ? "needs-improvement" : "good"; }(e.value, n), t(e)); }; }, m = function (t) { requestAnimationFrame(function () { return requestAnimationFrame(function () { return t(); }); }); }, p = function (t) { document.addEventListener("visibilitychange", function () { "hidden" === document.visibilityState && t(); }); }, v = function (t) { var e = !1; return function () { e || (t(), e = !0); }; }, g = -1, h = function () { return "hidden" !== document.visibilityState || document.prerendering ? 1 / 0 : 0; }, T = function (t) { "hidden" === document.visibilityState && g > -1 && (g = "visibilitychange" === t.type ? t.timeStamp : 0, E()); }, y = function () { addEventListener("visibilitychange", T, !0), addEventListener("prerenderingchange", T, !0); }, E = function () { removeEventListener("visibilitychange", T, !0), removeEventListener("prerenderingchange", T, !0); }, S = function () { return g < 0 && (g = h(), y(), u(function () { setTimeout(function () { g = h(), y(); }, 0); })), { get firstHiddenTime() { return g; } }; }, b = function (t) { document.prerendering ? addEventListener("prerenderingchange", function () { return t(); }, !0) : t(); }, L = [1800, 3e3], C = function (t, e) { e = e || {}, b(function () { var n, r = S(), i = f("FCP"), a = d("paint", function (t) { t.forEach(function (t) { "first-contentful-paint" === t.name && (a.disconnect(), t.startTime < r.firstHiddenTime && (i.value = Math.max(t.startTime - s(), 0), i.entries.push(t), n(!0))); }); }); a && (n = l(t, i, L, e.reportAllChanges), u(function (r) { i = f("FCP"), n = l(t, i, L, e.reportAllChanges), m(function () { i.value = performance.now() - r.timeStamp, n(!0); }); })); }); }, M = [.1, .25], D = function (t, e) { !function (t, e) { e = e || {}, C(v(function () { var n, r = f("CLS", 0), i = 0, a = [], o = function (t) { t.forEach(function (t) { if (!t.hadRecentInput) { var e = a[0], n = a[a.length - 1]; i && t.startTime - n.startTime < 1e3 && t.startTime - e.startTime < 5e3 ? (i += t.value, a.push(t)) : (i = t.value, a = [t]); } }), i > r.value && (r.value = i, r.entries = a, n()); }, c = d("layout-shift", o); c && (n = l(t, r, M, e.reportAllChanges), p(function () { o(c.takeRecords()), n(!0); }), u(function () { i = 0, r = f("CLS", 0), n = l(t, r, M, e.reportAllChanges), m(function () { return n(); }); }), setTimeout(n, 0)); })); }(function (e) { var n = function (t) { var e, n = {}; if (t.entries.length) { var i = t.entries.reduce(function (t, e) { return t && t.value > e.value ? t : e; }); if (i && i.sources && i.sources.length) { var o = (e = i.sources).find(function (t) { return t.node && 1 === t.node.nodeType; }) || e[0]; o && (n = { largestShiftTarget: a(o.node), largestShiftTime: i.startTime, largestShiftValue: i.value, largestShiftSource: o, largestShiftEntry: i, loadState: r(i.startTime) }); } } return Object.assign(t, { attribution: n }); }(e); t(n); }, e); }, w = function (t, e) { C(function (e) { var i = function (t) { var e = { timeToFirstByte: 0, firstByteToFCP: t.value, loadState: r(c()) }; if (t.entries.length) { var i = n(), a = t.entries[t.entries.length - 1]; if (i) { var o = i.activationStart || 0, u = Math.max(0, i.responseStart - o); e = { timeToFirstByte: u, firstByteToFCP: t.value - u, loadState: r(t.entries[0].startTime), navigationEntry: i, fcpEntry: a }; } } return Object.assign(t, { attribution: e }); }(e); t(i); }, e); }, x = 0, I = 1 / 0, k = 0, A = function (t) { t.forEach(function (t) { t.interactionId && (I = Math.min(I, t.interactionId), k = Math.max(k, t.interactionId), x = k ? (k - I) / 7 + 1 : 0); }); }, F = function () { return t ? x : performance.interactionCount || 0; }, P = function () { "interactionCount" in performance || t || (t = d("event", A, { type: "event", buffered: !0, durationThreshold: 0 })); }, B = [], O = new Map(), R = 0, j = function () { var t = Math.min(B.length - 1, Math.floor((F() - R) / 50)); return B[t]; }, q = [], H = function (t) { if (q.forEach(function (e) { return e(t); }), t.interactionId || "first-input" === t.entryType) { var e = B[B.length - 1], n = O.get(t.interactionId); if (n || B.length < 10 || t.duration > e.latency) { if (n) t.duration > n.latency ? (n.entries = [t], n.latency = t.duration) : t.duration === n.latency && t.startTime === n.entries[0].startTime && n.entries.push(t);else { var r = { id: t.interactionId, latency: t.duration, entries: [t] }; O.set(r.id, r), B.push(r); } B.sort(function (t, e) { return e.latency - t.latency; }), B.length > 10 && B.splice(10).forEach(function (t) { return O.delete(t.id); }); } } }, N = function (t) { var e = self.requestIdleCallback || self.setTimeout, n = -1; return t = v(t), "hidden" === document.visibilityState ? t() : (n = e(t), p(t)), n; }, W = [200, 500], z = function (t, e) { "PerformanceEventTiming" in self && "interactionId" in PerformanceEventTiming.prototype && (e = e || {}, b(function () { var n; P(); var r, i = f("INP"), a = function (t) { N(function () { t.forEach(H); var e = j(); e && e.latency !== i.value && (i.value = e.latency, i.entries = e.entries, r()); }); }, o = d("event", a, { durationThreshold: null !== (n = e.durationThreshold) && void 0 !== n ? n : 40 }); r = l(t, i, W, e.reportAllChanges), o && (o.observe({ type: "first-input", buffered: !0 }), p(function () { a(o.takeRecords()), r(!0); }), u(function () { R = F(), B.length = 0, O.clear(), i = f("INP"), r = l(t, i, W, e.reportAllChanges); })); })); }, U = [], V = [], _ = 0, G = new WeakMap(), J = new Map(), K = -1, Q = function (t) { U = U.concat(t), X(); }, X = function () { K < 0 && (K = N(Y)); }, Y = function () { J.size > 10 && J.forEach(function (t, e) { O.has(e) || J.delete(e); }); var t = B.map(function (t) { return G.get(t.entries[0]); }), e = V.length - 50; V = V.filter(function (n, r) { return r >= e || t.includes(n); }); for (var n = new Set(), r = 0; r < V.length; r++) { var i = V[r]; nt(i.startTime, i.processingEnd).forEach(function (t) { n.add(t); }); } var a = U.length - 1 - 50; U = U.filter(function (t, e) { return t.startTime > _ && e > a || n.has(t); }), K = -1; }; q.push(function (t) { t.interactionId && t.target && !J.has(t.interactionId) && J.set(t.interactionId, t.target); }, function (t) { var e, n = t.startTime + t.duration; _ = Math.max(_, t.processingEnd); for (var r = V.length - 1; r >= 0; r--) { var i = V[r]; if (Math.abs(n - i.renderTime) <= 8) { (e = i).startTime = Math.min(t.startTime, e.startTime), e.processingStart = Math.min(t.processingStart, e.processingStart), e.processingEnd = Math.max(t.processingEnd, e.processingEnd), e.entries.push(t); break; } } e || (e = { startTime: t.startTime, processingStart: t.processingStart, processingEnd: t.processingEnd, renderTime: n, entries: [t] }, V.push(e)), (t.interactionId || "first-input" === t.entryType) && G.set(t, e), X(); }); var Z, $, tt, et, nt = function (t, e) { for (var n, r = [], i = 0; n = U[i]; i++) if (!(n.startTime + n.duration < t)) { if (n.startTime > e) break; r.push(n); } return r; }, rt = function (t, n) { e || (e = d("long-animation-frame", Q)), z(function (e) { var n = function (t) { var e = t.entries[0], n = G.get(e), i = e.processingStart, o = n.processingEnd, c = n.entries.sort(function (t, e) { return t.processingStart - e.processingStart; }), u = nt(e.startTime, o), s = t.entries.find(function (t) { return t.target; }), f = s && s.target || J.get(e.interactionId), d = [e.startTime + e.duration, o].concat(u.map(function (t) { return t.startTime + t.duration; })), l = Math.max.apply(Math, d), m = { interactionTarget: a(f), interactionTargetElement: f, interactionType: e.name.startsWith("key") ? "keyboard" : "pointer", interactionTime: e.startTime, nextPaintTime: l, processedEventEntries: c, longAnimationFrameEntries: u, inputDelay: i - e.startTime, processingDuration: o - i, presentationDelay: Math.max(l - o, 0), loadState: r(e.startTime) }; return Object.assign(t, { attribution: m }); }(e); t(n); }, n); }, it = [2500, 4e3], at = {}, ot = function (t, e) { !function (t, e) { e = e || {}, b(function () { var n, r = S(), i = f("LCP"), a = function (t) { e.reportAllChanges || (t = t.slice(-1)), t.forEach(function (t) { t.startTime < r.firstHiddenTime && (i.value = Math.max(t.startTime - s(), 0), i.entries = [t], n()); }); }, o = d("largest-contentful-paint", a); if (o) { n = l(t, i, it, e.reportAllChanges); var c = v(function () { at[i.id] || (a(o.takeRecords()), o.disconnect(), at[i.id] = !0, n(!0)); }); ["keydown", "click"].forEach(function (t) { addEventListener(t, function () { return N(c); }, { once: !0, capture: !0 }); }), p(c), u(function (r) { i = f("LCP"), n = l(t, i, it, e.reportAllChanges), m(function () { i.value = performance.now() - r.timeStamp, at[i.id] = !0, n(!0); }); }); } }); }(function (e) { var r = function (t) { var e = { timeToFirstByte: 0, resourceLoadDelay: 0, resourceLoadDuration: 0, elementRenderDelay: t.value }; if (t.entries.length) { var r = n(); if (r) { var i = r.activationStart || 0, o = t.entries[t.entries.length - 1], c = o.url && performance.getEntriesByType("resource").filter(function (t) { return t.name === o.url; })[0], u = Math.max(0, r.responseStart - i), s = Math.max(u, c ? (c.requestStart || c.startTime) - i : 0), f = Math.max(s, c ? c.responseEnd - i : 0), d = Math.max(f, o.startTime - i); e = { element: a(o.element), timeToFirstByte: u, resourceLoadDelay: s - u, resourceLoadDuration: f - s, elementRenderDelay: d - f, navigationEntry: r, lcpEntry: o }, o.url && (e.url = o.url), c && (e.lcpResourceEntry = c); } } return Object.assign(t, { attribution: e }); }(e); t(r); }, e); }, ct = [800, 1800], ut = function t(e) { document.prerendering ? b(function () { return t(e); }) : "complete" !== document.readyState ? addEventListener("load", function () { return t(e); }, !0) : setTimeout(e, 0); }, st = function (t, e) { e = e || {}; var r = f("TTFB"), i = l(t, r, ct, e.reportAllChanges); ut(function () { var a = n(); a && (r.value = Math.max(a.responseStart - s(), 0), r.entries = [a], i(!0), u(function () { r = f("TTFB", 0), (i = l(t, r, ct, e.reportAllChanges))(!0); })); }); }, ft = function (t, e) { st(function (e) { var n = function (t) { var e = { waitingDuration: 0, cacheDuration: 0, dnsDuration: 0, connectionDuration: 0, requestDuration: 0 }; if (t.entries.length) { var n = t.entries[0], r = n.activationStart || 0, i = Math.max((n.workerStart || n.fetchStart) - r, 0), a = Math.max(n.domainLookupStart - r, 0), o = Math.max(n.connectStart - r, 0), c = Math.max(n.connectEnd - r, 0); e = { waitingDuration: i, cacheDuration: a - i, dnsDuration: o - a, connectionDuration: c - o, requestDuration: t.value - c, navigationEntry: n }; } return Object.assign(t, { attribution: e }); }(e); t(n); }, e); }, dt = { passive: !0, capture: !0 }, lt = new Date(), mt = function (t, e) { Z || (Z = e, $ = t, tt = new Date(), gt(removeEventListener), pt()); }, pt = function () { if ($ >= 0 && $ < tt - lt) { var t = { entryType: "first-input", name: Z.type, target: Z.target, cancelable: Z.cancelable, startTime: Z.timeStamp, processingStart: Z.timeStamp + $ }; et.forEach(function (e) { e(t); }), et = []; } }, vt = function (t) { if (t.cancelable) { var e = (t.timeStamp > 1e12 ? new Date() : performance.now()) - t.timeStamp; "pointerdown" == t.type ? function (t, e) { var n = function () { mt(t, e), i(); }, r = function () { i(); }, i = function () { removeEventListener("pointerup", n, dt), removeEventListener("pointercancel", r, dt); }; addEventListener("pointerup", n, dt), addEventListener("pointercancel", r, dt); }(e, t) : mt(e, t); } }, gt = function (t) { ["mousedown", "keydown", "touchstart", "pointerdown"].forEach(function (e) { return t(e, vt, dt); }); }, ht = [100, 300], Tt = function (t, e) { e = e || {}, b(function () { var n, r = S(), i = f("FID"), a = function (t) { t.startTime < r.firstHiddenTime && (i.value = t.processingStart - t.startTime, i.entries.push(t), n(!0)); }, o = function (t) { t.forEach(a); }, c = d("first-input", o); n = l(t, i, ht, e.reportAllChanges), c && (p(v(function () { o(c.takeRecords()), c.disconnect(); })), u(function () { var r; i = f("FID"), n = l(t, i, ht, e.reportAllChanges), et = [], $ = -1, Z = null, gt(addEventListener), r = a, et.push(r), pt(); })); }); }, yt = function (t, e) { Tt(function (e) { var n = function (t) { var e = t.entries[0], n = { eventTarget: a(e.target), eventType: e.name, eventTime: e.startTime, eventEntry: e, loadState: r(e.startTime) }; return Object.assign(t, { attribution: n }); }(e); t(n); }, e); }; /***/ }) }]) //# sourceMappingURL=3511.js.map