react-native-onyx 1.0.36 → 1.0.38

package/dist/web.development.js

@@ -15,10 +15,17 @@ return /******/ (() => { // webpackBootstrap
 /*!***********************!*\
   !*** ./lib/Logger.js ***!
   \***********************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));exports.logAlert = logAlert;exports.logInfo = logInfo;exports.registerLogger = registerLogger; // Logging callback
-var logger = function logger() {};
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "logAlert": () => (/* binding */ logAlert),
+/* harmony export */   "logInfo": () => (/* binding */ logInfo),
+/* harmony export */   "registerLogger": () => (/* binding */ registerLogger)
+/* harmony export */ });
+// Logging callback
+let logger = () => {};
 
 /**
  * Register the logging callback
@@ -35,7 +42,7 @@ function registerLogger(callback) {
  * @param {String} message
  */
 function logAlert(message) {
-  logger({ message: "[Onyx] " + message, level: 'alert' });
+  logger({ message: `[Onyx] ${message}`, level: 'alert' });
 }
 
 /**
@@ -44,31 +51,52 @@ function logAlert(message) {
  * @param {String} message
  */
 function logInfo(message) {
-  logger({ message: "[Onyx] " + message, level: 'info' });
+  logger({ message: `[Onyx] ${message}`, level: 'info' });
 }
 
+
+
 /***/ }),
 
 /***/ "./lib/Onyx.js":
 /*!*********************!*\
   !*** ./lib/Onyx.js ***!
   \*********************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;var _slicedToArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/slicedToArray */ "./node_modules/@babel/runtime/helpers/slicedToArray.js"));var _toConsumableArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "./node_modules/@babel/runtime/helpers/toConsumableArray.js"));var _defineProperty2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/defineProperty.js"));
-var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
-var _str = _interopRequireDefault(__webpack_require__(/*! expensify-common/lib/str */ "expensify-common/lib/str"));
-var _fastEquals = __webpack_require__(/*! fast-equals */ "fast-equals");
-var _get = _interopRequireDefault(__webpack_require__(/*! lodash/get */ "lodash/get"));
-var _storage = _interopRequireDefault(__webpack_require__(/*! ./storage */ "./lib/storage/index.web.js"));
-var Logger = _interopRequireWildcard(__webpack_require__(/*! ./Logger */ "./lib/Logger.js"));
-var _OnyxCache = _interopRequireDefault(__webpack_require__(/*! ./OnyxCache */ "./lib/OnyxCache.js"));
-var _createDeferredTask = _interopRequireDefault(__webpack_require__(/*! ./createDeferredTask */ "./lib/createDeferredTask.js"));
-var _fastMerge = _interopRequireDefault(__webpack_require__(/*! ./fastMerge */ "./lib/fastMerge.js"));
-var PerformanceUtils = _interopRequireWildcard(__webpack_require__(/*! ./metrics/PerformanceUtils */ "./lib/metrics/PerformanceUtils.js"));function _getRequireWildcardCache(nodeInterop) {if (typeof WeakMap !== "function") return null;var cacheBabelInterop = new WeakMap();var cacheNodeInterop = new WeakMap();return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {return nodeInterop ? cacheNodeInterop : cacheBabelInterop;})(nodeInterop);}function _interopRequireWildcard(obj, nodeInterop) {if (!nodeInterop && obj && obj.__esModule) {return obj;}if (obj === null || typeof obj !== "object" && typeof obj !== "function") {return { default: obj };}var cache = _getRequireWildcardCache(nodeInterop);if (cache && cache.has(obj)) {return cache.get(obj);}var newObj = {};var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;for (var key in obj) {if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;if (desc && (desc.get || desc.set)) {Object.defineProperty(newObj, key, desc);} else {newObj[key] = obj[key];}}}newObj.default = obj;if (cache) {cache.set(obj, newObj);}return newObj;} /* eslint-disable no-continue */
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! expensify-common/lib/str */ "expensify-common/lib/str");
+/* harmony import */ var expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var fast_equals__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! fast-equals */ "fast-equals");
+/* harmony import */ var fast_equals__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(fast_equals__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var lodash_get__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! lodash/get */ "lodash/get");
+/* harmony import */ var lodash_get__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(lodash_get__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./storage */ "./lib/storage/index.web.js");
+/* harmony import */ var _Logger__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./Logger */ "./lib/Logger.js");
+/* harmony import */ var _OnyxCache__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./OnyxCache */ "./lib/OnyxCache.js");
+/* harmony import */ var _createDeferredTask__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./createDeferredTask */ "./lib/createDeferredTask.js");
+/* harmony import */ var _fastMerge__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./fastMerge */ "./lib/fastMerge.js");
+/* harmony import */ var _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./metrics/PerformanceUtils */ "./lib/metrics/PerformanceUtils.js");
+/* eslint-disable no-continue */
+
+
+
+
+
+
+
+
+
+
 
 // Method constants
-var METHOD = {
+const METHOD = {
   SET: 'set',
   MERGE: 'merge',
   MERGE_COLLECTION: 'mergecollection',
@@ -76,30 +104,30 @@ var METHOD = {
 };
 
 // Keeps track of the last connectionID that was used so we can keep incrementing it
-var lastConnectionID = 0;
+let lastConnectionID = 0;
 
 // Holds a mapping of all the react components that want their state subscribed to a store key
-var callbackToStateMapping = {};
+const callbackToStateMapping = {};
 
 // Stores all of the keys that Onyx can use. Must be defined in init().
-var onyxKeys = {};
+let onyxKeys = {};
 
 // Holds a list of keys that have been directly subscribed to or recently modified from least to most recent
-var recentlyAccessedKeys = [];
+let recentlyAccessedKeys = [];
 
 // Holds a list of keys that are safe to remove when we reach max storage. If a key does not match with
 // whatever appears in this list it will NEVER be a candidate for eviction.
-var evictionAllowList = [];
+let evictionAllowList = [];
 
 // Holds a map of keys and connectionID arrays whose keys will never be automatically evicted as
 // long as we have at least one subscriber that returns false for the canEvict property.
-var evictionBlocklist = {};
+const evictionBlocklist = {};
 
 // Optional user-provided key value states set when Onyx initializes or clears
-var defaultKeyStates = {};
+let defaultKeyStates = {};
 
 // Connections can be made before `Onyx.init`. They would wait for this task before resolving
-var deferredInitTask = (0, _createDeferredTask.default)();
+const deferredInitTask = (0,_createDeferredTask__WEBPACK_IMPORTED_MODULE_4__["default"])();
 
 /**
  * Uses a selector string or function to return a simplified version of sourceData
@@ -109,9 +137,9 @@ var deferredInitTask = (0, _createDeferredTask.default)();
  *      If it's a function, it is passed the sourceData and it should return the simplified data
  * @returns {Mixed}
  */
-var getSubsetOfData = function getSubsetOfData(sourceData, selector) {return _underscore.default.isFunction(selector) ?
-  selector(sourceData) :
-  (0, _get.default)(sourceData, selector);};
+const getSubsetOfData = (sourceData, selector) => underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(selector) ?
+selector(sourceData) :
+lodash_get__WEBPACK_IMPORTED_MODULE_3___default()(sourceData, selector);
 
 /**
  * Takes a collection of items (eg. {testKey_1:{a:'a'}, testKey_2:{b:'b'}})
@@ -121,12 +149,12 @@ var getSubsetOfData = function getSubsetOfData(sourceData, selector) {return _un
  * @param {String|Function} selector (see method docs for getSubsetOfData() for full details)
  * @returns {Object}
  */
-var reduceCollectionWithSelector = function reduceCollectionWithSelector(collection, selector) {return _underscore.default.reduce(collection, function (finalCollection, item, key) {
-    // eslint-disable-next-line no-param-reassign
-    finalCollection[key] = getSubsetOfData(item, selector);
+const reduceCollectionWithSelector = (collection, selector) => underscore__WEBPACK_IMPORTED_MODULE_0___default().reduce(collection, (finalCollection, item, key) => {
+  // eslint-disable-next-line no-param-reassign
+  finalCollection[key] = getSubsetOfData(item, selector);
 
-    return finalCollection;
-  }, {});};
+  return finalCollection;
+}, {});
 
 /**
  * Get some data from the store
@@ -137,26 +165,26 @@ var reduceCollectionWithSelector = function reduceCollectionWithSelector(collect
  */
 function get(key) {
   // When we already have the value in cache - resolve right away
-  if (_OnyxCache.default.hasCacheForKey(key)) {
-    return Promise.resolve(_OnyxCache.default.getValue(key));
+  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].hasCacheForKey(key)) {
+    return Promise.resolve(_OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getValue(key));
   }
 
-  var taskName = "get:" + key;
+  const taskName = `get:${key}`;
 
   // When a value retrieving task for this key is still running hook to it
-  if (_OnyxCache.default.hasPendingTask(taskName)) {
-    return _OnyxCache.default.getTaskPromise(taskName);
+  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].hasPendingTask(taskName)) {
+    return _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getTaskPromise(taskName);
   }
 
   // Otherwise retrieve the value from storage and capture a promise to aid concurrent usages
-  var promise = _storage.default.getItem(key).
-  then(function (val) {
-    _OnyxCache.default.set(key, val);
+  const promise = _storage__WEBPACK_IMPORTED_MODULE_6__["default"].getItem(key).
+  then((val) => {
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].set(key, val);
     return val;
   }).
-  catch(function (err) {return Logger.logInfo("Unable to get item from persistent storage. Key: " + key + " Error: " + err);});
+  catch((err) => _Logger__WEBPACK_IMPORTED_MODULE_7__.logInfo(`Unable to get item from persistent storage. Key: ${key} Error: ${err}`));
 
-  return _OnyxCache.default.captureTask(taskName, promise);
+  return _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].captureTask(taskName, promise);
 }
 
 /**
@@ -166,26 +194,26 @@ function get(key) {
  */
 function getAllKeys() {
   // When we've already read stored keys, resolve right away
-  var storedKeys = _OnyxCache.default.getAllKeys();
+  const storedKeys = _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getAllKeys();
   if (storedKeys.length > 0) {
     return Promise.resolve(storedKeys);
   }
 
-  var taskName = 'getAllKeys';
+  const taskName = 'getAllKeys';
 
   // When a value retrieving task for all keys is still running hook to it
-  if (_OnyxCache.default.hasPendingTask(taskName)) {
-    return _OnyxCache.default.getTaskPromise(taskName);
+  if (_OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].hasPendingTask(taskName)) {
+    return _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getTaskPromise(taskName);
   }
 
   // Otherwise retrieve the keys from storage and capture a promise to aid concurrent usages
-  var promise = _storage.default.getAllKeys().
-  then(function (keys) {
-    _underscore.default.each(keys, function (key) {return _OnyxCache.default.addKey(key);});
+  const promise = _storage__WEBPACK_IMPORTED_MODULE_6__["default"].getAllKeys().
+  then((keys) => {
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(keys, (key) => _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].addKey(key));
     return keys;
   });
 
-  return _OnyxCache.default.captureTask(taskName, promise);
+  return _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].captureTask(taskName, promise);
 }
 
 /**
@@ -197,7 +225,7 @@ function getAllKeys() {
  * @returns {Boolean}
  */
 function isCollectionKey(key) {
-  return _underscore.default.contains(_underscore.default.values(onyxKeys.COLLECTION), key);
+  return underscore__WEBPACK_IMPORTED_MODULE_0___default().contains(underscore__WEBPACK_IMPORTED_MODULE_0___default().values(onyxKeys.COLLECTION), key);
 }
 
 /**
@@ -206,7 +234,7 @@ function isCollectionKey(key) {
  * @returns {Boolean}
  */
 function isCollectionMemberKey(collectionKey, key) {
-  return _str.default.startsWith(key, collectionKey) && key.length > collectionKey.length;
+  return expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1___default().startsWith(key, collectionKey) && key.length > collectionKey.length;
 }
 
 /**
@@ -220,7 +248,7 @@ function isCollectionMemberKey(collectionKey, key) {
  */
 function isKeyMatch(configKey, key) {
   return isCollectionKey(configKey) ?
-  _str.default.startsWith(key, configKey) :
+  expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1___default().startsWith(key, configKey) :
   configKey === key;
 }
 
@@ -233,7 +261,7 @@ function isKeyMatch(configKey, key) {
  * @returns {Boolean}
  */
 function isSafeEvictionKey(testKey) {
-  return _underscore.default.some(evictionAllowList, function (key) {return isKeyMatch(key, testKey);});
+  return underscore__WEBPACK_IMPORTED_MODULE_0___default().some(evictionAllowList, (key) => isKeyMatch(key, testKey));
 }
 
 /**
@@ -243,7 +271,7 @@ function isSafeEvictionKey(testKey) {
  * @param {String} key
  */
 function removeLastAccessedKey(key) {
-  recentlyAccessedKeys = _underscore.default.without(recentlyAccessedKeys, key);
+  recentlyAccessedKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().without(recentlyAccessedKeys, key);
 }
 
 /**
@@ -273,7 +301,7 @@ function addLastAccessedKey(key) {
  * @param {Number} connectionID
  */
 function removeFromEvictionBlockList(key, connectionID) {
-  evictionBlocklist[key] = _underscore.default.without(evictionBlocklist[key] || [], connectionID);
+  evictionBlocklist[key] = underscore__WEBPACK_IMPORTED_MODULE_0___default().without(evictionBlocklist[key] || [], connectionID);
 
   // Remove the key if there are no more subscribers
   if (evictionBlocklist[key].length === 0) {
@@ -309,9 +337,9 @@ function addToEvictionBlockList(key, connectionID) {
  */
 function addAllSafeEvictionKeysToRecentlyAccessedList() {
   return getAllKeys().
-  then(function (keys) {
-    _underscore.default.each(evictionAllowList, function (safeEvictionKey) {
-      _underscore.default.each(keys, function (key) {
+  then((keys) => {
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(evictionAllowList, (safeEvictionKey) => {
+      underscore__WEBPACK_IMPORTED_MODULE_0___default().each(keys, (key) => {
         if (!isKeyMatch(safeEvictionKey, key)) {
           return;
         }
@@ -327,12 +355,12 @@ function addAllSafeEvictionKeysToRecentlyAccessedList() {
  * @returns {Object}
  */
 function getCachedCollection(collectionKey) {
-  var collectionMemberKeys = _underscore.default.filter(_OnyxCache.default.getAllKeys(),
-  function (storedKey) {return isCollectionMemberKey(collectionKey, storedKey);});
+  const collectionMemberKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().filter(_OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getAllKeys(),
+  (storedKey) => isCollectionMemberKey(collectionKey, storedKey));
 
 
-  return _underscore.default.reduce(collectionMemberKeys, function (prev, curr) {
-    var cachedValue = _OnyxCache.default.getValue(curr);
+  return underscore__WEBPACK_IMPORTED_MODULE_0___default().reduce(collectionMemberKeys, (prev, curr) => {
+    const cachedValue = _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getValue(curr);
     if (!cachedValue) {
       return prev;
     }
@@ -354,60 +382,60 @@ function keysChanged(collectionKey, partialCollection) {
   // We are iterating over all subscribers similar to keyChanged(). However, we are looking for subscribers who are subscribing to either a collection key or
   // individual collection key member for the collection that is being updated. It is important to note that the collection parameter cane be a PARTIAL collection
   // and does not represent all of the combined keys and values for a collection key. It is just the "new" data that was merged in via mergeCollection().
-  var stateMappingKeys = _underscore.default.keys(callbackToStateMapping);var _loop = function _loop(
-  i) {
-    var subscriber = callbackToStateMapping[stateMappingKeys[i]];
+  const stateMappingKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(callbackToStateMapping);
+  for (let i = 0; i < stateMappingKeys.length; i++) {
+    const subscriber = callbackToStateMapping[stateMappingKeys[i]];
     if (!subscriber) {
-      return "continue";
+      continue;
     }
 
     // Skip iteration if we do not have a collection key or a collection member key on this subscriber
-    if (!_str.default.startsWith(subscriber.key, collectionKey)) {
-      return "continue";
+    if (!expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1___default().startsWith(subscriber.key, collectionKey)) {
+      continue;
     }
 
     /**
      * e.g. Onyx.connect({key: ONYXKEYS.COLLECTION.REPORT, callback: ...});
      */
-    var isSubscribedToCollectionKey = subscriber.key === collectionKey;
+    const isSubscribedToCollectionKey = subscriber.key === collectionKey;
 
     /**
      * e.g. Onyx.connect({key: `${ONYXKEYS.COLLECTION.REPORT}{reportID}`, callback: ...});
      */
-    var isSubscribedToCollectionMemberKey = isCollectionMemberKey(collectionKey, subscriber.key);
+    const isSubscribedToCollectionMemberKey = isCollectionMemberKey(collectionKey, subscriber.key);
 
     // We prepare the "cached collection" which is the entire collection + the new partial data that
     // was merged in via mergeCollection().
-    var cachedCollection = getCachedCollection(collectionKey);
+    const cachedCollection = getCachedCollection(collectionKey);
 
     // Regular Onyx.connect() subscriber found.
-    if (_underscore.default.isFunction(subscriber.callback)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(subscriber.callback)) {
       // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
       // send the whole cached collection.
       if (isSubscribedToCollectionKey) {
         if (subscriber.waitForCollectionCallback) {
           subscriber.callback(cachedCollection);
-          return "continue";
+          continue;
         }
 
         // If they are not using waitForCollectionCallback then we notify the subscriber with
         // the new merged data but only for any keys in the partial collection.
-        var dataKeys = _underscore.default.keys(partialCollection);
-        for (var j = 0; j < dataKeys.length; j++) {
-          var dataKey = dataKeys[j];
+        const dataKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(partialCollection);
+        for (let j = 0; j < dataKeys.length; j++) {
+          const dataKey = dataKeys[j];
           subscriber.callback(cachedCollection[dataKey], dataKey);
         }
-        return "continue";
+        continue;
       }
 
       // And if the subscriber is specifically only tracking a particular collection member key then we will
       // notify them with the cached data for that key only.
       if (isSubscribedToCollectionMemberKey) {
         subscriber.callback(cachedCollection[subscriber.key], subscriber.key);
-        return "continue";
+        continue;
       }
 
-      return "continue";
+      continue;
     }
 
     // React component subscriber found.
@@ -418,78 +446,78 @@ function keysChanged(collectionKey, partialCollection) {
         // If the subscriber has a selector, then the component's state must only be updated with the data
         // returned by the selector.
         if (subscriber.selector) {
-          subscriber.withOnyxInstance.setState(function (prevState) {
-            var previousData = reduceCollectionWithSelector(prevState[subscriber.statePropertyName], subscriber.selector);
-            var newData = reduceCollectionWithSelector(cachedCollection, subscriber.selector);
-
-            if (!(0, _fastEquals.deepEqual)(previousData, newData)) {
-              return (0, _defineProperty2.default)({},
-              subscriber.statePropertyName, newData);
-
+          subscriber.withOnyxInstance.setState((prevState) => {
+            const previousData = reduceCollectionWithSelector(prevState[subscriber.statePropertyName], subscriber.selector);
+            const newData = reduceCollectionWithSelector(cachedCollection, subscriber.selector);
+
+            if (!(0,fast_equals__WEBPACK_IMPORTED_MODULE_2__.deepEqual)(previousData, newData)) {
+              return {
+                [subscriber.statePropertyName]: newData
+              };
             }
             return null;
           });
-          return "continue";
+          continue;
         }
 
-        subscriber.withOnyxInstance.setState(function (prevState) {
-          var finalCollection = _underscore.default.clone(prevState[subscriber.statePropertyName] || {});
-          var dataKeys = _underscore.default.keys(partialCollection);
-          for (var _j = 0; _j < dataKeys.length; _j++) {
-            var _dataKey = dataKeys[_j];
-            finalCollection[_dataKey] = cachedCollection[_dataKey];
+        subscriber.withOnyxInstance.setState((prevState) => {
+          const finalCollection = underscore__WEBPACK_IMPORTED_MODULE_0___default().clone(prevState[subscriber.statePropertyName] || {});
+          const dataKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(partialCollection);
+          for (let j = 0; j < dataKeys.length; j++) {
+            const dataKey = dataKeys[j];
+            finalCollection[dataKey] = cachedCollection[dataKey];
           }
 
-          PerformanceUtils.logSetStateCall(subscriber, prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
-          return (0, _defineProperty2.default)({},
-          subscriber.statePropertyName, finalCollection);
-
+          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, prevState[subscriber.statePropertyName], finalCollection, 'keysChanged', collectionKey);
+          return {
+            [subscriber.statePropertyName]: finalCollection
+          };
         });
-        return "continue";
+        continue;
       }
 
       // If a React component is only interested in a single key then we can set the cached value directly to the state name.
       if (isSubscribedToCollectionMemberKey) {
         // However, we only want to update this subscriber if the partial data contains a change.
         // Otherwise, we would update them with a value they already have and trigger an unnecessary re-render.
-        var dataFromCollection = partialCollection[subscriber.key];
-        if (_underscore.default.isUndefined(dataFromCollection)) {
-          return "continue";
+        const dataFromCollection = partialCollection[subscriber.key];
+        if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isUndefined(dataFromCollection)) {
+          continue;
         }
 
         // If the subscriber has a selector, then the component's state must only be updated with the data
         // returned by the selector and the state should only change when the subset of data changes from what
         // it was previously.
         if (subscriber.selector) {
-          subscriber.withOnyxInstance.setState(function (prevState) {
-            var prevData = prevState[subscriber.statePropertyName];
-            var newData = getSubsetOfData(cachedCollection[subscriber.key], subscriber.selector);
-            if (!(0, _fastEquals.deepEqual)(prevData, newData)) {
-              PerformanceUtils.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
-              return (0, _defineProperty2.default)({},
-              subscriber.statePropertyName, newData);
-
+          subscriber.withOnyxInstance.setState((prevState) => {
+            const prevData = prevState[subscriber.statePropertyName];
+            const newData = getSubsetOfData(cachedCollection[subscriber.key], subscriber.selector);
+            if (!(0,fast_equals__WEBPACK_IMPORTED_MODULE_2__.deepEqual)(prevData, newData)) {
+              _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, prevData, newData, 'keysChanged', collectionKey);
+              return {
+                [subscriber.statePropertyName]: newData
+              };
             }
 
             return null;
           });
-          return "continue";
+          continue;
         }
 
-        subscriber.withOnyxInstance.setState(function (prevState) {
-          var data = cachedCollection[subscriber.key];
-          var previousData = prevState[subscriber.statePropertyName];
+        subscriber.withOnyxInstance.setState((prevState) => {
+          const data = cachedCollection[subscriber.key];
+          const previousData = prevState[subscriber.statePropertyName];
           if (data === previousData) {
             return null;
           }
 
-          PerformanceUtils.logSetStateCall(subscriber, previousData, data, 'keysChanged', collectionKey);
-          return (0, _defineProperty2.default)({},
-          subscriber.statePropertyName, data);
-
+          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, previousData, data, 'keysChanged', collectionKey);
+          return {
+            [subscriber.statePropertyName]: data
+          };
         });
       }
-    }};for (var i = 0; i < stateMappingKeys.length; i++) {var _ret = _loop(i);if (_ret === "continue") continue;
+    }
   }
 }
 
@@ -506,7 +534,7 @@ function keysChanged(collectionKey, partialCollection) {
  */
 function keyChanged(key, data, canUpdateSubscriber) {
   // Add or remove this key from the recentlyAccessedKeys lists
-  if (!_underscore.default.isNull(data)) {
+  if (!underscore__WEBPACK_IMPORTED_MODULE_0___default().isNull(data)) {
     addLastAccessedKey(key);
   } else {
     removeLastAccessedKey(key);
@@ -515,24 +543,24 @@ function keyChanged(key, data, canUpdateSubscriber) {
   // We are iterating over all subscribers to see if they are interested in the key that has just changed. If the subscriber's  key is a collection key then we will
   // notify them if the key that changed is a collection member. Or if it is a regular key notify them when there is an exact match. Depending on whether the subscriber
   // was connected via withOnyx we will call setState() directly on the withOnyx instance. If it is a regular connection we will pass the data to the provided callback.
-  var stateMappingKeys = _underscore.default.keys(callbackToStateMapping);var _loop2 = function _loop2(
-  i) {
-    var subscriber = callbackToStateMapping[stateMappingKeys[i]];
-    if (!subscriber || !isKeyMatch(subscriber.key, key) || _underscore.default.isFunction(canUpdateSubscriber) && !canUpdateSubscriber(subscriber)) {
-      return "continue";
+  const stateMappingKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(callbackToStateMapping);
+  for (let i = 0; i < stateMappingKeys.length; i++) {
+    const subscriber = callbackToStateMapping[stateMappingKeys[i]];
+    if (!subscriber || !isKeyMatch(subscriber.key, key) || underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(canUpdateSubscriber) && !canUpdateSubscriber(subscriber)) {
+      continue;
     }
 
     // Subscriber is a regular call to connect() and provided a callback
-    if (_underscore.default.isFunction(subscriber.callback)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(subscriber.callback)) {
       if (isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
-        var cachedCollection = getCachedCollection(subscriber.key);
+        const cachedCollection = getCachedCollection(subscriber.key);
         cachedCollection[key] = data;
         subscriber.callback(cachedCollection);
-        return "continue";
+        continue;
       }
 
       subscriber.callback(data, key);
-      return "continue";
+      continue;
     }
 
     // Subscriber connected via withOnyx() HOC
@@ -542,72 +570,72 @@ function keyChanged(key, data, canUpdateSubscriber) {
         // If the subscriber has a selector, then the consumer of this data must only be given the data
         // returned by the selector and only when the selected data has changed.
         if (subscriber.selector) {
-          subscriber.withOnyxInstance.setState(function (prevState) {
-            var prevData = prevState[subscriber.statePropertyName];
-            var newData = (0, _defineProperty2.default)({},
-            key, getSubsetOfData(data, subscriber.selector));
-
-            var prevDataWithNewData = Object.assign({},
-            prevData, (0, _defineProperty2.default)({},
-            key, getSubsetOfData(data, subscriber.selector)));
-
-            if (!(0, _fastEquals.deepEqual)(prevData, prevDataWithNewData)) {
-              PerformanceUtils.logSetStateCall(subscriber, prevData, newData, 'keyChanged', key);
-              return (0, _defineProperty2.default)({},
-              subscriber.statePropertyName, prevDataWithNewData);
-
+          subscriber.withOnyxInstance.setState((prevState) => {
+            const prevData = prevState[subscriber.statePropertyName];
+            const newData = {
+              [key]: getSubsetOfData(data, subscriber.selector)
+            };
+            const prevDataWithNewData = {
+              ...prevData,
+              [key]: getSubsetOfData(data, subscriber.selector)
+            };
+            if (!(0,fast_equals__WEBPACK_IMPORTED_MODULE_2__.deepEqual)(prevData, prevDataWithNewData)) {
+              _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, prevData, newData, 'keyChanged', key);
+              return {
+                [subscriber.statePropertyName]: prevDataWithNewData
+              };
             }
             return null;
           });
-          return "continue";
+          continue;
         }
 
-        subscriber.withOnyxInstance.setState(function (prevState) {
-          var collection = prevState[subscriber.statePropertyName] || {};
-          var newCollection = Object.assign({},
-          collection, (0, _defineProperty2.default)({},
-          key, data));
-
-          PerformanceUtils.logSetStateCall(subscriber, collection, newCollection, 'keyChanged', key);
-          return (0, _defineProperty2.default)({},
-          subscriber.statePropertyName, newCollection);
-
+        subscriber.withOnyxInstance.setState((prevState) => {
+          const collection = prevState[subscriber.statePropertyName] || {};
+          const newCollection = {
+            ...collection,
+            [key]: data
+          };
+          _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, collection, newCollection, 'keyChanged', key);
+          return {
+            [subscriber.statePropertyName]: newCollection
+          };
         });
-        return "continue";
+        continue;
       }
 
       // If the subscriber has a selector, then the component's state must only be updated with the data
       // returned by the selector and only if the selected data has changed.
       if (subscriber.selector) {
-        subscriber.withOnyxInstance.setState(function (prevState) {
-          var previousValue = getSubsetOfData(prevState[subscriber.statePropertyName], subscriber.selector);
-          var newValue = getSubsetOfData(data, subscriber.selector);
-          if (!(0, _fastEquals.deepEqual)(previousValue, newValue)) {
-            return (0, _defineProperty2.default)({},
-            subscriber.statePropertyName, newValue);
-
+        subscriber.withOnyxInstance.setState((prevState) => {
+          const previousValue = getSubsetOfData(prevState[subscriber.statePropertyName], subscriber.selector);
+          const newValue = getSubsetOfData(data, subscriber.selector);
+          if (!(0,fast_equals__WEBPACK_IMPORTED_MODULE_2__.deepEqual)(previousValue, newValue)) {
+            return {
+              [subscriber.statePropertyName]: newValue
+            };
           }
           return null;
         });
-        return "continue";
+        continue;
       }
 
       // If we did not match on a collection key then we just set the new data to the state property
-      subscriber.withOnyxInstance.setState(function (prevState) {
-        var previousData = prevState[subscriber.statePropertyName];
+      subscriber.withOnyxInstance.setState((prevState) => {
+        const previousData = prevState[subscriber.statePropertyName];
         if (previousData === data) {
           return null;
         }
 
-        PerformanceUtils.logSetStateCall(subscriber, previousData, data, 'keyChanged', key);
-        return (0, _defineProperty2.default)({},
-        subscriber.statePropertyName, data);
-
+        _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(subscriber, previousData, data, 'keyChanged', key);
+        return {
+          [subscriber.statePropertyName]: data
+        };
       });
-      return "continue";
+      continue;
     }
 
-    console.error('Warning: Found a matching subscriber to a key that changed, but no callback or withOnyxInstance could be found.');};for (var i = 0; i < stateMappingKeys.length; i++) {var _ret2 = _loop2(i);if (_ret2 === "continue") continue;
+    console.error('Warning: Found a matching subscriber to a key that changed, but no callback or withOnyxInstance could be found.');
   }
 }
 
@@ -633,7 +661,7 @@ function sendDataToConnection(mapping, val, matchedKey) {
   }
 
   if (mapping.withOnyxInstance) {
-    var newData = val;
+    let newData = val;
 
     // If the mapping has a selector, then the component's state must only be updated with the data
     // returned by the selector.
@@ -645,12 +673,12 @@ function sendDataToConnection(mapping, val, matchedKey) {
       }
     }
 
-    PerformanceUtils.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
+    _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.logSetStateCall(mapping, null, newData, 'sendDataToConnection');
     mapping.withOnyxInstance.setWithOnyxState(mapping.statePropertyName, newData);
     return;
   }
 
-  if (_underscore.default.isFunction(mapping.callback)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(mapping.callback)) {
     mapping.callback(val, matchedKey);
   }
 }
@@ -668,13 +696,13 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
   }
 
   // Try to free some cache whenever we connect to a safe eviction key
-  _OnyxCache.default.removeLeastRecentlyUsedKeys();
+  _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].removeLeastRecentlyUsedKeys();
 
   if (mapping.withOnyxInstance && !isCollectionKey(mapping.key)) {
     // All React components subscribing to a key flagged as a safe eviction key must implement the canEvict property.
-    if (_underscore.default.isUndefined(mapping.canEvict)) {
-      throw new Error("Cannot subscribe to safe eviction key '" +
-      mapping.key + "' without providing a canEvict value.");
+    if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isUndefined(mapping.canEvict)) {
+      throw new Error(
+      `Cannot subscribe to safe eviction key '${mapping.key}' without providing a canEvict value.`);
 
     }
 
@@ -690,13 +718,13 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
  * @param {Object} mapping
  */
 function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
-  Promise.all(_underscore.default.map(matchingKeys, function (key) {return get(key);})).
-  then(function (values) {return _underscore.default.reduce(values, function (finalObject, value, i) {
-      // eslint-disable-next-line no-param-reassign
-      finalObject[matchingKeys[i]] = value;
-      return finalObject;
-    }, {});}).
-  then(function (val) {return sendDataToConnection(mapping, val);});
+  Promise.all(underscore__WEBPACK_IMPORTED_MODULE_0___default().map(matchingKeys, (key) => get(key))).
+  then((values) => underscore__WEBPACK_IMPORTED_MODULE_0___default().reduce(values, (finalObject, value, i) => {
+    // eslint-disable-next-line no-param-reassign
+    finalObject[matchingKeys[i]] = value;
+    return finalObject;
+  }, {})).
+  then((val) => sendDataToConnection(mapping, val));
 }
 
 /**
@@ -725,7 +753,7 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @returns {Number} an ID to use when calling disconnect
  */
 function connect(mapping) {
-  var connectionID = lastConnectionID++;
+  const connectionID = lastConnectionID++;
   callbackToStateMapping[connectionID] = mapping;
   callbackToStateMapping[connectionID].connectionID = connectionID;
 
@@ -735,13 +763,13 @@ function connect(mapping) {
 
   // Commit connection only after init passes
   deferredInitTask.promise.
-  then(function () {return addKeyToRecentlyAccessedIfNeeded(mapping);}).
+  then(() => addKeyToRecentlyAccessedIfNeeded(mapping)).
   then(getAllKeys).
-  then(function (keys) {
+  then((keys) => {
     // We search all the keys in storage to see if any are a "match" for the subscriber we are connecting so that we
     // can send data back to the subscriber. Note that multiple keys can match as a subscriber could either be
     // subscribed to a "collection key" or a single key.
-    var matchingKeys = _underscore.default.filter(keys, function (key) {return isKeyMatch(mapping.key, key);});
+    const matchingKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().filter(keys, (key) => isKeyMatch(mapping.key, key));
 
     // If the key being connected to does not exist we initialize the value with null. For subscribers that connected
     // directly via connect() they will simply get a null value sent to them without any information about which key matched
@@ -755,7 +783,7 @@ function connect(mapping) {
     // When using a callback subscriber we will either trigger the provided callback for each key we find or combine all values
     // into an object and just make a single call. The latter behavior is enabled by providing a waitForCollectionCallback key
     // combined with a subscription to a collection key.
-    if (_underscore.default.isFunction(mapping.callback)) {
+    if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(mapping.callback)) {
       if (isCollectionKey(mapping.key)) {
         if (mapping.waitForCollectionCallback) {
           getCollectionDataAndSendAsObject(matchingKeys, mapping);
@@ -763,14 +791,14 @@ function connect(mapping) {
         }
 
         // We did not opt into using waitForCollectionCallback mode so the callback is called for every matching key.
-        var _loop3 = function _loop3(i) {
-          get(matchingKeys[i]).then(function (val) {return sendDataToConnection(mapping, val, matchingKeys[i]);});};for (var i = 0; i < matchingKeys.length; i++) {_loop3(i);
+        for (let i = 0; i < matchingKeys.length; i++) {
+          get(matchingKeys[i]).then((val) => sendDataToConnection(mapping, val, matchingKeys[i]));
         }
         return;
       }
 
       // If we are not subscribed to a collection key then there's only a single key to send an update for.
-      get(mapping.key).then(function (val) {return sendDataToConnection(mapping, val, mapping.key);});
+      get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key));
       return;
     }
 
@@ -783,7 +811,7 @@ function connect(mapping) {
       }
 
       // If the subscriber is not using a collection key then we just send a single value back to the subscriber
-      get(mapping.key).then(function (val) {return sendDataToConnection(mapping, val, mapping.key);});
+      get(mapping.key).then((val) => sendDataToConnection(mapping, val, mapping.key));
       return;
     }
 
@@ -832,7 +860,7 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
  */
 // eslint-disable-next-line rulesdir/no-negated-variables
 function notifySubscribersOnNextTick(key, value, canUpdateSubscriber) {
-  Promise.resolve().then(function () {return keyChanged(key, value, canUpdateSubscriber);});
+  Promise.resolve().then(() => keyChanged(key, value, canUpdateSubscriber));
 }
 
 /**
@@ -845,7 +873,7 @@ function notifySubscribersOnNextTick(key, value, canUpdateSubscriber) {
  */
 // eslint-disable-next-line rulesdir/no-negated-variables
 function notifyCollectionSubscribersOnNextTick(key, value) {
-  Promise.resolve().then(function () {return keysChanged(key, value);});
+  Promise.resolve().then(() => keysChanged(key, value));
 }
 
 /**
@@ -856,9 +884,9 @@ function notifyCollectionSubscribersOnNextTick(key, value) {
  * @return {Promise}
  */
 function remove(key) {
-  _OnyxCache.default.drop(key);
+  _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].drop(key);
   notifySubscribersOnNextTick(key, null);
-  return _storage.default.removeItem(key);
+  return _storage__WEBPACK_IMPORTED_MODULE_6__["default"].removeItem(key);
 }
 
 /**
@@ -873,25 +901,25 @@ function remove(key) {
  * @return {Promise}
  */
 function evictStorageAndRetry(error, onyxMethod) {for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {args[_key - 2] = arguments[_key];}
-  Logger.logInfo("Handled error: " + error);
+  _Logger__WEBPACK_IMPORTED_MODULE_7__.logInfo(`Handled error: ${error}`);
 
-  if (error && _str.default.startsWith(error.message, 'Failed to execute \'put\' on \'IDBObjectStore\'')) {
-    Logger.logAlert('Attempted to set invalid data set in Onyx. Please ensure all data is serializable.');
+  if (error && expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_1___default().startsWith(error.message, 'Failed to execute \'put\' on \'IDBObjectStore\'')) {
+    _Logger__WEBPACK_IMPORTED_MODULE_7__.logAlert('Attempted to set invalid data set in Onyx. Please ensure all data is serializable.');
     throw error;
   }
 
   // Find the first key that we can remove that has no subscribers in our blocklist
-  var keyForRemoval = _underscore.default.find(recentlyAccessedKeys, function (key) {return !evictionBlocklist[key];});
+  const keyForRemoval = underscore__WEBPACK_IMPORTED_MODULE_0___default().find(recentlyAccessedKeys, (key) => !evictionBlocklist[key]);
 
   if (!keyForRemoval) {
-    Logger.logAlert('Out of storage. But found no acceptable keys to remove.');
+    _Logger__WEBPACK_IMPORTED_MODULE_7__.logAlert('Out of storage. But found no acceptable keys to remove.');
     throw error;
   }
 
   // Remove the least recently viewed key that is not currently being accessed and retry.
-  Logger.logInfo("Out of storage. Evicting least recently accessed key (" + keyForRemoval + ") and retrying.");
+  _Logger__WEBPACK_IMPORTED_MODULE_7__.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying.`);
   return remove(keyForRemoval).
-  then(function () {return onyxMethod.apply(void 0, args);});
+  then(() => onyxMethod(...args));
 }
 
 /**
@@ -903,30 +931,30 @@ function evictStorageAndRetry(error, onyxMethod) {for (var _len = arguments.leng
  * @returns {Promise}
  */
 function set(key, value) {
-  if (_underscore.default.isNull(value)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isNull(value)) {
     return remove(key);
   }
 
   // eslint-disable-next-line no-use-before-define
   if (hasPendingMergeForKey(key)) {
-    Logger.logAlert("Onyx.set() called after Onyx.merge() for key: " + key + ". It is recommended to use set() or merge() not both.");
+    _Logger__WEBPACK_IMPORTED_MODULE_7__.logAlert(`Onyx.set() called after Onyx.merge() for key: ${key}. It is recommended to use set() or merge() not both.`);
   }
 
   // If the value in the cache is the same as what we have then do not update subscribers unless they
   // have initWithStoredValues: false then they MUST get all updates even if nothing has changed.
-  if (!_OnyxCache.default.hasValueChanged(key, value)) {
-    _OnyxCache.default.addToAccessedKeys(key);
-    notifySubscribersOnNextTick(key, value, function (subscriber) {return subscriber.initWithStoredValues === false;});
+  if (!_OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].hasValueChanged(key, value)) {
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].addToAccessedKeys(key);
+    notifySubscribersOnNextTick(key, value, (subscriber) => subscriber.initWithStoredValues === false);
     return Promise.resolve();
   }
 
   // Adds the key to cache when it's not available
-  _OnyxCache.default.set(key, value);
+  _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].set(key, value);
   notifySubscribersOnNextTick(key, value);
 
   // Write the thing to persistent storage, which will trigger a storage event for any other tabs open on this domain
-  return _storage.default.setItem(key, value).
-  catch(function (error) {return evictStorageAndRetry(error, set, key, value);});
+  return _storage__WEBPACK_IMPORTED_MODULE_6__["default"].setItem(key, value).
+  catch((error) => evictStorageAndRetry(error, set, key, value));
 }
 
 /**
@@ -938,7 +966,7 @@ function set(key, value) {
  * @return {Array} an array of key - value pairs <[key, value]>
  */
 function prepareKeyValuePairsForStorage(data) {
-  return _underscore.default.map(data, function (value, key) {return [key, value];});
+  return underscore__WEBPACK_IMPORTED_MODULE_0___default().map(data, (value, key) => [key, value]);
 }
 
 /**
@@ -950,20 +978,20 @@ function prepareKeyValuePairsForStorage(data) {
  * @returns {Promise}
  */
 function multiSet(data) {
-  var keyValuePairs = prepareKeyValuePairsForStorage(data);
+  const keyValuePairs = prepareKeyValuePairsForStorage(data);
 
-  _underscore.default.each(data, function (val, key) {
+  underscore__WEBPACK_IMPORTED_MODULE_0___default().each(data, (val, key) => {
     // Update cache and optimistically inform subscribers on the next tick
-    _OnyxCache.default.set(key, val);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].set(key, val);
     notifySubscribersOnNextTick(key, val);
   });
 
-  return _storage.default.multiSet(keyValuePairs).
-  catch(function (error) {return evictStorageAndRetry(error, multiSet, data);});
+  return _storage__WEBPACK_IMPORTED_MODULE_6__["default"].multiSet(keyValuePairs).
+  catch((error) => evictStorageAndRetry(error, multiSet, data));
 }
 
 // Key/value store of Onyx key and arrays of values to merge
-var mergeQueue = {};
+const mergeQueue = {};
 
 /**
  * @private
@@ -987,33 +1015,33 @@ function hasPendingMergeForKey(key) {
  * @returns {*}
  */
 function applyMerge(key, data) {
-  var mergeValues = mergeQueue[key];
-  if (_underscore.default.isArray(data) || _underscore.default.every(mergeValues, _underscore.default.isArray)) {
+  const mergeValues = mergeQueue[key];
+  if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isArray(data) || underscore__WEBPACK_IMPORTED_MODULE_0___default().every(mergeValues, (underscore__WEBPACK_IMPORTED_MODULE_0___default().isArray))) {
     // Array values will always just concatenate
     // more items onto the end of the array
-    return _underscore.default.reduce(mergeValues, function (modifiedData, mergeValue) {return [].concat((0, _toConsumableArray2.default)(
-      modifiedData), (0, _toConsumableArray2.default)(
-      mergeValue));},
+    return underscore__WEBPACK_IMPORTED_MODULE_0___default().reduce(mergeValues, (modifiedData, mergeValue) => [
+    ...modifiedData,
+    ...mergeValue],
     data || []);
   }
 
-  if (_underscore.default.isObject(data) || _underscore.default.every(mergeValues, _underscore.default.isObject)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_0___default().isObject(data) || underscore__WEBPACK_IMPORTED_MODULE_0___default().every(mergeValues, (underscore__WEBPACK_IMPORTED_MODULE_0___default().isObject))) {
     // Object values are merged one after the other
-    return _underscore.default.reduce(mergeValues, function (modifiedData, mergeValue) {
+    return underscore__WEBPACK_IMPORTED_MODULE_0___default().reduce(mergeValues, (modifiedData, mergeValue) => {
       // lodash adds a small overhead so we don't use it here
       // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
-      var newData = Object.assign({}, (0, _fastMerge.default)(modifiedData, mergeValue));
+      const newData = Object.assign({}, (0,_fastMerge__WEBPACK_IMPORTED_MODULE_9__["default"])(modifiedData, mergeValue));
 
       // We will also delete any object keys that are undefined or null.
       // Deleting keys is not supported by AsyncStorage so we do it this way.
       // Remove all first level keys that are explicitly set to null.
-      return _underscore.default.omit(newData, function (value, finalObjectKey) {return _underscore.default.isNull(mergeValue[finalObjectKey]);});
+      return underscore__WEBPACK_IMPORTED_MODULE_0___default().omit(newData, (value, finalObjectKey) => underscore__WEBPACK_IMPORTED_MODULE_0___default().isNull(mergeValue[finalObjectKey]));
     }, data || {});
   }
 
   // If we have anything else we can't merge it so we'll
   // simply return the last value that was queued
-  return _underscore.default.last(mergeValues);
+  return underscore__WEBPACK_IMPORTED_MODULE_0___default().last(mergeValues);
 }
 
 /**
@@ -1046,9 +1074,9 @@ function merge(key, value) {
 
   mergeQueue[key] = [value];
   return get(key).
-  then(function (data) {
+  then((data) => {
     try {
-      var modifiedData = applyMerge(key, data);
+      const modifiedData = applyMerge(key, data);
 
       // Clean up the write queue so we
       // don't apply these changes again
@@ -1056,7 +1084,7 @@ function merge(key, value) {
 
       return set(key, modifiedData);
     } catch (error) {
-      Logger.logAlert("An error occurred while applying merge for key: " + key + ", Error: " + error);
+      _Logger__WEBPACK_IMPORTED_MODULE_7__.logAlert(`An error occurred while applying merge for key: ${key}, Error: ${error}`);
     }
 
     return Promise.resolve();
@@ -1069,13 +1097,13 @@ function merge(key, value) {
  * @returns {Promise}
  */
 function initializeWithDefaultKeyStates() {
-  return _storage.default.multiGet(_underscore.default.keys(defaultKeyStates)).
-  then(function (pairs) {
-    var asObject = _underscore.default.object(pairs);
+  return _storage__WEBPACK_IMPORTED_MODULE_6__["default"].multiGet(underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(defaultKeyStates)).
+  then((pairs) => {
+    const asObject = underscore__WEBPACK_IMPORTED_MODULE_0___default().object(pairs);
 
-    var merged = (0, _fastMerge.default)(asObject, defaultKeyStates);
-    _OnyxCache.default.merge(merged);
-    _underscore.default.each(merged, function (val, key) {return keyChanged(key, val);});
+    const merged = (0,_fastMerge__WEBPACK_IMPORTED_MODULE_9__["default"])(asObject, defaultKeyStates);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].merge(merged);
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(merged, (val, key) => keyChanged(key, val));
   });
 }
 
@@ -1101,49 +1129,49 @@ function initializeWithDefaultKeyStates() {
  * @param {Array} keysToPreserve is a list of ONYXKEYS that should not be cleared with the rest of the data
  * @returns {Promise<void>}
  */
-function clear() {var keysToPreserve = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+function clear() {let keysToPreserve = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return getAllKeys().
-  then(function (keys) {
-    var keyValuesToReset = [];
-    var defaultKeys = _underscore.default.keys(defaultKeyStates);
+  then((keys) => {
+    const keyValuesToReset = [];
+    const defaultKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(defaultKeyStates);
 
     // Get all the values for the keys that need to be preserved. These key/value pairs will be set
     // in Onyx after the database is cleared().
-    var keyValuesToPreserve = _underscore.default.map(keysToPreserve, function (key) {return [key, _OnyxCache.default.getValue(key)];});
+    const keyValuesToPreserve = underscore__WEBPACK_IMPORTED_MODULE_0___default().map(keysToPreserve, (key) => [key, _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].getValue(key)]);
 
     // The only keys that should not be cleared are:
     // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
     //      status, or activeClients need to remain in Onyx even when signed out)
     // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
     //      to null would cause unknown behavior)
-    var keysToClear = _underscore.default.difference(keys, keysToPreserve, defaultKeys);
-    keyValuesToReset.push.apply(keyValuesToReset, (0, _toConsumableArray2.default)(_underscore.default.map(keysToClear, function (key) {return [key, null];})));
+    const keysToClear = underscore__WEBPACK_IMPORTED_MODULE_0___default().difference(keys, keysToPreserve, defaultKeys);
+    keyValuesToReset.push(...underscore__WEBPACK_IMPORTED_MODULE_0___default().map(keysToClear, (key) => [key, null]));
 
     // Remove any keysToPreserve from the defaultKeyStates because if they are passed in it has been explicitly
     // called out to preserve those values instead of resetting them back
     // to the default.
-    var defaultKeyValuePairs = _underscore.default.pairs(_underscore.default.omit.apply(_underscore.default, [defaultKeyStates].concat((0, _toConsumableArray2.default)(keysToPreserve))));
+    const defaultKeyValuePairs = underscore__WEBPACK_IMPORTED_MODULE_0___default().pairs(underscore__WEBPACK_IMPORTED_MODULE_0___default().omit(defaultKeyStates, ...keysToPreserve));
 
     // Add the default key value pairs to the keyValuesToReset so that they get set back to their default values
     // when we clear Onyx
-    keyValuesToReset.push.apply(keyValuesToReset, (0, _toConsumableArray2.default)(defaultKeyValuePairs));
+    keyValuesToReset.push(...defaultKeyValuePairs);
 
     // We now have all the key/values that need to be reset, but we're not done yet!
     // There will be two groups of key/values and they each need to be updated a little bit differently.
     // Collection keys need to be notified differently than non collection keys
-    var keyValuesToResetAsCollection = {};
-    var keyValuesToResetIndividually = {};
+    const keyValuesToResetAsCollection = {};
+    const keyValuesToResetIndividually = {};
 
     // Make sure that we also reset the cache values before clearing the values from storage.
     // We do this before clearing Storage so that any call to clear() followed by merge() on a key with a
     // default state results in the merged value getting saved, since the update from the merge() call would
     // happen on the tick after the update from this clear()
-    _underscore.default.each(keyValuesToReset, function (keyValue) {
-      var key = keyValue[0];
-      var value = keyValue[1];
-      _OnyxCache.default.set(key, value);
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(keyValuesToReset, (keyValue) => {
+      const key = keyValue[0];
+      const value = keyValue[1];
+      _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].set(key, value);
 
-      var collectionKey = key.substring(0, key.indexOf('_') + 1);
+      const collectionKey = key.substring(0, key.indexOf('_') + 1);
       if (collectionKey) {
         if (!keyValuesToResetAsCollection[collectionKey]) {
           keyValuesToResetAsCollection[collectionKey] = {};
@@ -1156,18 +1184,18 @@ function clear() {var keysToPreserve = arguments.length > 0 && arguments[0] !==
     });
 
     // Notify the subscribers for each key/value group so they can receive the new values
-    _underscore.default.each(keyValuesToResetIndividually, function (value, key) {
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(keyValuesToResetIndividually, (value, key) => {
       notifySubscribersOnNextTick(key, value);
     });
-    _underscore.default.each(keyValuesToResetAsCollection, function (value, key) {
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(keyValuesToResetAsCollection, (value, key) => {
       notifyCollectionSubscribersOnNextTick(key, value);
     });
 
     // Call clear() and make sure that the default key/values and the key/values from the parameter
     // are preserved in storage. This makes sure to always leave storage in a state that contains
     // all the default values and any additional values that we want to remain after the database is cleared.
-    return _storage.default.clear().
-    then(function () {return _storage.default.multiSet([].concat((0, _toConsumableArray2.default)(defaultKeyValuePairs), (0, _toConsumableArray2.default)(keyValuesToPreserve)));});
+    return _storage__WEBPACK_IMPORTED_MODULE_6__["default"].clear().
+    then(() => _storage__WEBPACK_IMPORTED_MODULE_6__["default"].multiSet([...defaultKeyValuePairs, ...keyValuesToPreserve]));
   });
 }
 
@@ -1186,54 +1214,54 @@ function clear() {var keysToPreserve = arguments.length > 0 && arguments[0] !==
  * @returns {Promise}
  */
 function mergeCollection(collectionKey, collection) {
-  if (!_underscore.default.isObject(collection) || _underscore.default.isArray(collection) || _underscore.default.isEmpty(collection)) {
-    Logger.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
+  if (!underscore__WEBPACK_IMPORTED_MODULE_0___default().isObject(collection) || underscore__WEBPACK_IMPORTED_MODULE_0___default().isArray(collection) || underscore__WEBPACK_IMPORTED_MODULE_0___default().isEmpty(collection)) {
+    _Logger__WEBPACK_IMPORTED_MODULE_7__.logInfo('mergeCollection() called with invalid or empty value. Skipping this update.');
     return Promise.resolve();
   }
 
   // Confirm all the collection keys belong to the same parent
-  _underscore.default.each(collection, function (_data, dataKey) {
+  underscore__WEBPACK_IMPORTED_MODULE_0___default().each(collection, (_data, dataKey) => {
     if (isKeyMatch(collectionKey, dataKey)) {
       return;
     }
 
-    throw new Error("Provided collection doesn't have all its data belonging to the same parent. CollectionKey: " + collectionKey + ", DataKey: " + dataKey);
+    throw new Error(`Provided collection doesn't have all its data belonging to the same parent. CollectionKey: ${collectionKey}, DataKey: ${dataKey}`);
   });
 
   return getAllKeys().
-  then(function (persistedKeys) {
+  then((persistedKeys) => {
     // Split to keys that exist in storage and keys that don't
-    var _$chain$keys$partitio = _underscore.default.chain(collection).
-      keys().
-      partition(function (key) {return persistedKeys.includes(key);}).
-      value(),_$chain$keys$partitio2 = (0, _slicedToArray2.default)(_$chain$keys$partitio, 2),existingKeys = _$chain$keys$partitio2[0],newKeys = _$chain$keys$partitio2[1];
+    const [existingKeys, newKeys] = underscore__WEBPACK_IMPORTED_MODULE_0___default().chain(collection).
+    keys().
+    partition((key) => persistedKeys.includes(key)).
+    value();
 
-    var existingKeyCollection = _underscore.default.pick(collection, existingKeys);
-    var newCollection = _underscore.default.pick(collection, newKeys);
-    var keyValuePairsForExistingCollection = prepareKeyValuePairsForStorage(existingKeyCollection);
-    var keyValuePairsForNewCollection = prepareKeyValuePairsForStorage(newCollection);
+    const existingKeyCollection = underscore__WEBPACK_IMPORTED_MODULE_0___default().pick(collection, existingKeys);
+    const newCollection = underscore__WEBPACK_IMPORTED_MODULE_0___default().pick(collection, newKeys);
+    const keyValuePairsForExistingCollection = prepareKeyValuePairsForStorage(existingKeyCollection);
+    const keyValuePairsForNewCollection = prepareKeyValuePairsForStorage(newCollection);
 
-    var promises = [];
+    const promises = [];
 
     // New keys will be added via multiSet while existing keys will be updated using multiMerge
     // This is because setting a key that doesn't exist yet with multiMerge will throw errors
     if (keyValuePairsForExistingCollection.length > 0) {
-      promises.push(_storage.default.multiMerge(keyValuePairsForExistingCollection));
+      promises.push(_storage__WEBPACK_IMPORTED_MODULE_6__["default"].multiMerge(keyValuePairsForExistingCollection));
     }
 
     if (keyValuePairsForNewCollection.length > 0) {
-      promises.push(_storage.default.multiSet(keyValuePairsForNewCollection));
+      promises.push(_storage__WEBPACK_IMPORTED_MODULE_6__["default"].multiSet(keyValuePairsForNewCollection));
     }
 
     // Prefill cache if necessary by calling get() on any existing keys and then merge original data to cache
     // and update all subscribers
-    Promise.all(_underscore.default.map(existingKeys, get)).then(function () {
-      _OnyxCache.default.merge(collection);
+    Promise.all(underscore__WEBPACK_IMPORTED_MODULE_0___default().map(existingKeys, get)).then(() => {
+      _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].merge(collection);
       keysChanged(collectionKey, collection);
     });
 
     return Promise.all(promises).
-    catch(function (error) {return evictStorageAndRetry(error, mergeCollection, collection);});
+    catch((error) => evictStorageAndRetry(error, mergeCollection, collection));
   });
 }
 
@@ -1245,18 +1273,18 @@ function mergeCollection(collectionKey, collection) {
  */
 function update(data) {
   // First, validate the Onyx object is in the format we expect
-  _underscore.default.each(data, function (_ref9) {var onyxMethod = _ref9.onyxMethod,key = _ref9.key;
-    if (!_underscore.default.contains([METHOD.CLEAR, METHOD.SET, METHOD.MERGE, METHOD.MERGE_COLLECTION], onyxMethod)) {
-      throw new Error("Invalid onyxMethod " + onyxMethod + " in Onyx update.");
+  underscore__WEBPACK_IMPORTED_MODULE_0___default().each(data, (_ref) => {let { onyxMethod, key } = _ref;
+    if (!underscore__WEBPACK_IMPORTED_MODULE_0___default().contains([METHOD.CLEAR, METHOD.SET, METHOD.MERGE, METHOD.MERGE_COLLECTION], onyxMethod)) {
+      throw new Error(`Invalid onyxMethod ${onyxMethod} in Onyx update.`);
     }
-    if (onyxMethod !== METHOD.CLEAR && !_underscore.default.isString(key)) {
-      throw new Error("Invalid " + typeof key + " key provided in Onyx update. Onyx key must be of type string.");
+    if (onyxMethod !== METHOD.CLEAR && !underscore__WEBPACK_IMPORTED_MODULE_0___default().isString(key)) {
+      throw new Error(`Invalid ${typeof key} key provided in Onyx update. Onyx key must be of type string.`);
     }
   });
 
-  var promises = [];
+  const promises = [];
 
-  _underscore.default.each(data, function (_ref10) {var onyxMethod = _ref10.onyxMethod,key = _ref10.key,value = _ref10.value;
+  underscore__WEBPACK_IMPORTED_MODULE_0___default().each(data, (_ref2) => {let { onyxMethod, key, value } = _ref2;
     switch (onyxMethod) {
       case METHOD.SET:
         promises.push(set(key, value));
@@ -1311,7 +1339,7 @@ function init()
 
 
 
-{var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},_ref11$keys = _ref11.keys,keys = _ref11$keys === void 0 ? {} : _ref11$keys,_ref11$initialKeyStat = _ref11.initialKeyStates,initialKeyStates = _ref11$initialKeyStat === void 0 ? {} : _ref11$initialKeyStat,_ref11$safeEvictionKe = _ref11.safeEvictionKeys,safeEvictionKeys = _ref11$safeEvictionKe === void 0 ? [] : _ref11$safeEvictionKe,_ref11$maxCachedKeysC = _ref11.maxCachedKeysCount,maxCachedKeysCount = _ref11$maxCachedKeysC === void 0 ? 1000 : _ref11$maxCachedKeysC,_ref11$captureMetrics = _ref11.captureMetrics,captureMetrics = _ref11$captureMetrics === void 0 ? false : _ref11$captureMetrics,_ref11$shouldSyncMult = _ref11.shouldSyncMultipleInstances,shouldSyncMultipleInstances = _ref11$shouldSyncMult === void 0 ? Boolean(__webpack_require__.g.localStorage) : _ref11$shouldSyncMult,_ref11$debugSetState = _ref11.debugSetState,debugSetState = _ref11$debugSetState === void 0 ? false : _ref11$debugSetState;
+{let { keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, captureMetrics = false, shouldSyncMultipleInstances = Boolean(__webpack_require__.g.localStorage), debugSetState = false } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   if (captureMetrics) {
     // The code here is only bundled and applied when the captureMetrics is set
     // eslint-disable-next-line no-use-before-define
@@ -1319,11 +1347,11 @@ function init()
   }
 
   if (debugSetState) {
-    PerformanceUtils.setShouldDebugSetState(true);
+    _metrics_PerformanceUtils__WEBPACK_IMPORTED_MODULE_8__.setShouldDebugSetState(true);
   }
 
   if (maxCachedKeysCount > 0) {
-    _OnyxCache.default.setRecentKeysLimit(maxCachedKeysCount);
+    _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].setRecentKeysLimit(maxCachedKeysCount);
   }
 
   // Let Onyx know about all of our keys
@@ -1342,30 +1370,30 @@ function init()
 
   then(deferredInitTask.resolve);
 
-  if (shouldSyncMultipleInstances && _underscore.default.isFunction(_storage.default.keepInstancesSync)) {
-    _storage.default.keepInstancesSync(function (key, value) {
-      _OnyxCache.default.set(key, value);
+  if (shouldSyncMultipleInstances && underscore__WEBPACK_IMPORTED_MODULE_0___default().isFunction(_storage__WEBPACK_IMPORTED_MODULE_6__["default"].keepInstancesSync)) {
+    _storage__WEBPACK_IMPORTED_MODULE_6__["default"].keepInstancesSync((key, value) => {
+      _OnyxCache__WEBPACK_IMPORTED_MODULE_5__["default"].set(key, value);
       keyChanged(key, value);
     });
   }
 }
 
-var Onyx = {
-  connect: connect,
-  disconnect: disconnect,
-  set: set,
-  multiSet: multiSet,
-  merge: merge,
-  mergeCollection: mergeCollection,
-  update: update,
-  clear: clear,
-  getAllKeys: getAllKeys,
-  init: init,
-  registerLogger: Logger.registerLogger,
-  addToEvictionBlockList: addToEvictionBlockList,
-  removeFromEvictionBlockList: removeFromEvictionBlockList,
-  isSafeEvictionKey: isSafeEvictionKey,
-  METHOD: METHOD
+const Onyx = {
+  connect,
+  disconnect,
+  set,
+  multiSet,
+  merge,
+  mergeCollection,
+  update,
+  clear,
+  getAllKeys,
+  init,
+  registerLogger: _Logger__WEBPACK_IMPORTED_MODULE_7__.registerLogger,
+  addToEvictionBlockList,
+  removeFromEvictionBlockList,
+  isSafeEvictionKey,
+  METHOD
 };
 
 /**
@@ -1375,7 +1403,7 @@ var Onyx = {
  */
 function applyDecorators() {
   // We're requiring the script dynamically here so that it's only evaluated when decorators are used
-  var decorate = __webpack_require__(/*! ./metrics */ "./lib/metrics/index.web.js");
+  const decorate = __webpack_require__(/*! ./metrics */ "./lib/metrics/index.web.js");
 
   // Re-assign with decorated functions
   /* eslint-disable no-func-assign */
@@ -1404,9 +1432,9 @@ function applyDecorators() {
   Onyx.getMetrics = decorate.getMetrics;
   Onyx.resetMetrics = decorate.resetMetrics;
   Onyx.printMetrics = decorate.printMetrics;
-}var _default =
+}
 
-Onyx;exports["default"] = _default;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Onyx);
 
 /***/ }),
 
@@ -1414,20 +1442,30 @@ Onyx;exports["default"] = _default;
 /*!**************************!*\
   !*** ./lib/OnyxCache.js ***!
   \**************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var fast_equals__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! fast-equals */ "fast-equals");
+/* harmony import */ var fast_equals__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fast_equals__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _fastMerge__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./fastMerge */ "./lib/fastMerge.js");
+
+
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;var _toConsumableArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/toConsumableArray */ "./node_modules/@babel/runtime/helpers/toConsumableArray.js"));var _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "./node_modules/@babel/runtime/helpers/classCallCheck.js"));var _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ "./node_modules/@babel/runtime/helpers/createClass.js"));var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
-var _fastEquals = __webpack_require__(/*! fast-equals */ "fast-equals");
-var _fastMerge = _interopRequireDefault(__webpack_require__(/*! ./fastMerge */ "./lib/fastMerge.js"));
 
-var isDefined = _underscore.default.negate(_underscore.default.isUndefined);
+const isDefined = underscore__WEBPACK_IMPORTED_MODULE_0___default().negate((underscore__WEBPACK_IMPORTED_MODULE_0___default().isUndefined));
 
 /**
  * In memory cache providing data by reference
  * Encapsulates Onyx cache related functionality
- */var
-OnyxCache = /*#__PURE__*/function () {
-  function OnyxCache() {(0, _classCallCheck2.default)(this, OnyxCache);
+ */
+class OnyxCache {
+  constructor() {
     /**
      * @private
      * Cache of all the storage keys available in persistent storage
@@ -1457,7 +1495,7 @@ OnyxCache = /*#__PURE__*/function () {
     this.pendingPromises = {};
 
     // bind all public methods to prevent problems with `this`
-    _underscore.default.bindAll(
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().bindAll(
     this,
     'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge',
     'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys',
@@ -1468,168 +1506,168 @@ OnyxCache = /*#__PURE__*/function () {
   /**
    * Get all the storage keys
    * @returns {string[]}
-   */(0, _createClass2.default)(OnyxCache, [{ key: "getAllKeys", value:
-    function getAllKeys() {
-      return Array.from(this.storageKeys);
-    }
-
-    /**
-     * Get a cached value from storage
-     * @param {string} key
-     * @returns {*}
-     */ }, { key: "getValue", value:
-    function getValue(key) {
-      this.addToAccessedKeys(key);
-      return this.storageMap[key];
-    }
+   */
+  getAllKeys() {
+    return Array.from(this.storageKeys);
+  }
 
-    /**
-     * Check whether cache has data for the given key
-     * @param {string} key
-     * @returns {boolean}
-     */ }, { key: "hasCacheForKey", value:
-    function hasCacheForKey(key) {
-      return isDefined(this.storageMap[key]);
-    }
+  /**
+   * Get a cached value from storage
+   * @param {string} key
+   * @returns {*}
+   */
+  getValue(key) {
+    this.addToAccessedKeys(key);
+    return this.storageMap[key];
+  }
 
-    /**
-     * Saves a key in the storage keys list
-     * Serves to keep the result of `getAllKeys` up to date
-     * @param {string} key
-     */ }, { key: "addKey", value:
-    function addKey(key) {
-      this.storageKeys.add(key);
-    }
+  /**
+   * Check whether cache has data for the given key
+   * @param {string} key
+   * @returns {boolean}
+   */
+  hasCacheForKey(key) {
+    return isDefined(this.storageMap[key]);
+  }
 
-    /**
-     * Set's a key value in cache
-     * Adds the key to the storage keys list as well
-     * @param {string} key
-     * @param {*} value
-     * @returns {*} value - returns the cache value
-     */ }, { key: "set", value:
-    function set(key, value) {
-      this.addKey(key);
-      this.addToAccessedKeys(key);
-      this.storageMap[key] = value;
-
-      return value;
-    }
+  /**
+   * Saves a key in the storage keys list
+   * Serves to keep the result of `getAllKeys` up to date
+   * @param {string} key
+   */
+  addKey(key) {
+    this.storageKeys.add(key);
+  }
 
-    /**
-     * Forget the cached value for the given key
-     * @param {string} key
-     */ }, { key: "drop", value:
-    function drop(key) {
-      delete this.storageMap[key];
-      this.storageKeys.delete(key);
-      this.recentKeys.delete(key);
-    }
+  /**
+   * Set's a key value in cache
+   * Adds the key to the storage keys list as well
+   * @param {string} key
+   * @param {*} value
+   * @returns {*} value - returns the cache value
+   */
+  set(key, value) {
+    this.addKey(key);
+    this.addToAccessedKeys(key);
+    this.storageMap[key] = value;
 
-    /**
-     * Deep merge data to cache, any non existing keys will be created
-     * @param {Record<string, *>} data - a map of (cache) key - values
-     */ }, { key: "merge", value:
-    function merge(data) {var _this = this;
-      if (!_underscore.default.isObject(data) || _underscore.default.isArray(data)) {
-        throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
-      }
+    return value;
+  }
 
-      // lodash adds a small overhead so we don't use it here
-      // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
-      this.storageMap = Object.assign({}, (0, _fastMerge.default)(this.storageMap, data));
+  /**
+   * Forget the cached value for the given key
+   * @param {string} key
+   */
+  drop(key) {
+    delete this.storageMap[key];
+    this.storageKeys.delete(key);
+    this.recentKeys.delete(key);
+  }
 
-      var storageKeys = this.getAllKeys();
-      var mergedKeys = _underscore.default.keys(data);
-      this.storageKeys = new Set([].concat((0, _toConsumableArray2.default)(storageKeys), (0, _toConsumableArray2.default)(mergedKeys)));
-      _underscore.default.each(mergedKeys, function (key) {return _this.addToAccessedKeys(key);});
+  /**
+   * Deep merge data to cache, any non existing keys will be created
+   * @param {Record<string, *>} data - a map of (cache) key - values
+   */
+  merge(data) {
+    if (!underscore__WEBPACK_IMPORTED_MODULE_0___default().isObject(data) || underscore__WEBPACK_IMPORTED_MODULE_0___default().isArray(data)) {
+      throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
     }
 
-    /**
-     * Check whether the given task is already running
-     * @param {string} taskName - unique name given for the task
-     * @returns {*}
-     */ }, { key: "hasPendingTask", value:
-    function hasPendingTask(taskName) {
-      return isDefined(this.pendingPromises[taskName]);
-    }
+    // lodash adds a small overhead so we don't use it here
+    // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
+    this.storageMap = Object.assign({}, (0,_fastMerge__WEBPACK_IMPORTED_MODULE_2__["default"])(this.storageMap, data));
 
-    /**
-     * Use this method to prevent concurrent calls for the same thing
-     * Instead of calling the same task again use the existing promise
-     * provided from this function
-     * @template T
-     * @param {string} taskName - unique name given for the task
-     * @returns {Promise<T>}
-     */ }, { key: "getTaskPromise", value:
-    function getTaskPromise(taskName) {
-      return this.pendingPromises[taskName];
-    }
+    const storageKeys = this.getAllKeys();
+    const mergedKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(data);
+    this.storageKeys = new Set([...storageKeys, ...mergedKeys]);
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(mergedKeys, (key) => this.addToAccessedKeys(key));
+  }
 
-    /**
-     * Capture a promise for a given task so other caller can
-     * hook up to the promise if it's still pending
-     * @template T
-     * @param {string} taskName - unique name for the task
-     * @param {Promise<T>} promise
-     * @returns {Promise<T>}
-     */ }, { key: "captureTask", value:
-    function captureTask(taskName, promise) {var _this2 = this;
-      this.pendingPromises[taskName] = promise.finally(function () {
-        delete _this2.pendingPromises[taskName];
-      });
+  /**
+   * Check whether the given task is already running
+   * @param {string} taskName - unique name given for the task
+   * @returns {*}
+   */
+  hasPendingTask(taskName) {
+    return isDefined(this.pendingPromises[taskName]);
+  }
 
-      return this.pendingPromises[taskName];
-    }
+  /**
+   * Use this method to prevent concurrent calls for the same thing
+   * Instead of calling the same task again use the existing promise
+   * provided from this function
+   * @template T
+   * @param {string} taskName - unique name given for the task
+   * @returns {Promise<T>}
+   */
+  getTaskPromise(taskName) {
+    return this.pendingPromises[taskName];
+  }
 
-    /**
-     * @private
-     * Adds a key to the top of the recently accessed keys
-     * @param {string} key
-     */ }, { key: "addToAccessedKeys", value:
-    function addToAccessedKeys(key) {
-      // Removing and re-adding a key ensures it's at the end of the list
-      this.recentKeys.delete(key);
-      this.recentKeys.add(key);
-    }
+  /**
+   * Capture a promise for a given task so other caller can
+   * hook up to the promise if it's still pending
+   * @template T
+   * @param {string} taskName - unique name for the task
+   * @param {Promise<T>} promise
+   * @returns {Promise<T>}
+   */
+  captureTask(taskName, promise) {
+    this.pendingPromises[taskName] = promise.finally(() => {
+      delete this.pendingPromises[taskName];
+    });
 
-    /**
-     * Remove keys that don't fall into the range of recently used keys
-     */ }, { key: "removeLeastRecentlyUsedKeys", value:
-    function removeLeastRecentlyUsedKeys() {
-      if (this.recentKeys.size <= this.maxRecentKeysSize) {
-        return;
-      }
+    return this.pendingPromises[taskName];
+  }
 
-      // Get the last N keys by doing a negative slice
-      var recentlyAccessed = (0, _toConsumableArray2.default)(this.recentKeys).slice(-this.maxRecentKeysSize);
-      var storageKeys = _underscore.default.keys(this.storageMap);
-      var keysToRemove = _underscore.default.difference(storageKeys, recentlyAccessed);
+  /**
+   * @private
+   * Adds a key to the top of the recently accessed keys
+   * @param {string} key
+   */
+  addToAccessedKeys(key) {
+    // Removing and re-adding a key ensures it's at the end of the list
+    this.recentKeys.delete(key);
+    this.recentKeys.add(key);
+  }
 
-      _underscore.default.each(keysToRemove, this.drop);
+  /**
+   * Remove keys that don't fall into the range of recently used keys
+   */
+  removeLeastRecentlyUsedKeys() {
+    if (this.recentKeys.size <= this.maxRecentKeysSize) {
+      return;
     }
 
-    /**
-     * Set the recent keys list size
-     * @param {number} limit
-     */ }, { key: "setRecentKeysLimit", value:
-    function setRecentKeysLimit(limit) {
-      this.maxRecentKeysSize = limit;
-    }
+    // Get the last N keys by doing a negative slice
+    const recentlyAccessed = [...this.recentKeys].slice(-this.maxRecentKeysSize);
+    const storageKeys = underscore__WEBPACK_IMPORTED_MODULE_0___default().keys(this.storageMap);
+    const keysToRemove = underscore__WEBPACK_IMPORTED_MODULE_0___default().difference(storageKeys, recentlyAccessed);
 
-    /**
-     * @param {String} key
-     * @param {*} value
-     * @returns {Boolean}
-     */ }, { key: "hasValueChanged", value:
-    function hasValueChanged(key, value) {
-      return !(0, _fastEquals.deepEqual)(this.storageMap[key], value);
-    } }]);return OnyxCache;}();
+    underscore__WEBPACK_IMPORTED_MODULE_0___default().each(keysToRemove, this.drop);
+  }
 
+  /**
+   * Set the recent keys list size
+   * @param {number} limit
+   */
+  setRecentKeysLimit(limit) {
+    this.maxRecentKeysSize = limit;
+  }
+
+  /**
+   * @param {String} key
+   * @param {*} value
+   * @returns {Boolean}
+   */
+  hasValueChanged(key, value) {
+    return !(0,fast_equals__WEBPACK_IMPORTED_MODULE_1__.deepEqual)(this.storageMap[key], value);
+  }
+}
 
-var instance = new OnyxCache();var _default =
+const instance = new OnyxCache();
 
-instance;exports["default"] = _default;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (instance);
 
 /***/ }),
 
@@ -1637,9 +1675,14 @@ instance;exports["default"] = _default;
 /*!**************************!*\
   !*** ./lib/SyncQueue.js ***!
   \**************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;var _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "./node_modules/@babel/runtime/helpers/classCallCheck.js"));var _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ "./node_modules/@babel/runtime/helpers/createClass.js")); /**
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* binding */ SyncQueue)
+/* harmony export */ });
+/**
  * Synchronous queue that can be used to ensure promise based tasks are run in sequence.
  * Pass to the constructor a function that returns a promise to run the task then add data.
  *
@@ -1651,12 +1694,12 @@ var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/inte
  *
  *     queue.push({key: 1, val: '1'});
  *     queue.push({key: 2, val: '2'});
- */var
-SyncQueue = /*#__PURE__*/function () {
+ */
+class SyncQueue {
   /**
    * @param {Function} run - must return a promise
    */
-  function SyncQueue(run) {(0, _classCallCheck2.default)(this, SyncQueue);
+  constructor(run) {
     this.queue = [];
     this.isProcessing = false;
     this.run = run;
@@ -1664,39 +1707,40 @@ SyncQueue = /*#__PURE__*/function () {
 
   /**
    * Stop the queue from being processed and clear out any existing tasks
-   */(0, _createClass2.default)(SyncQueue, [{ key: "abort", value:
-    function abort() {
-      this.queue = [];
-      this.isProcessing = false;
-    } }, { key: "process", value:
+   */
+  abort() {
+    this.queue = [];
+    this.isProcessing = false;
+  }
 
-    function process() {var _this = this;
-      if (this.isProcessing || this.queue.length === 0) {
-        return;
-      }
+  process() {
+    if (this.isProcessing || this.queue.length === 0) {
+      return;
+    }
 
-      this.isProcessing = true;
+    this.isProcessing = true;
 
-      var _this$queue$shift = this.queue.shift(),data = _this$queue$shift.data,resolve = _this$queue$shift.resolve,reject = _this$queue$shift.reject;
-      this.run(data).
-      then(resolve).
-      catch(reject).
-      finally(function () {
-        _this.isProcessing = false;
-        _this.process();
-      });
-    }
+    const { data, resolve, reject } = this.queue.shift();
+    this.run(data).
+    then(resolve).
+    catch(reject).
+    finally(() => {
+      this.isProcessing = false;
+      this.process();
+    });
+  }
 
-    /**
-     * @param {*} data
-     * @returns {Promise}
-     */ }, { key: "push", value:
-    function push(data) {var _this2 = this;
-      return new Promise(function (resolve, reject) {
-        _this2.queue.push({ resolve: resolve, reject: reject, data: data });
-        _this2.process();
-      });
-    } }]);return SyncQueue;}();exports["default"] = SyncQueue;
+  /**
+   * @param {*} data
+   * @returns {Promise}
+   */
+  push(data) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ resolve, reject, data });
+      this.process();
+    });
+  }
+}
 
 /***/ }),
 
@@ -1704,9 +1748,14 @@ SyncQueue = /*#__PURE__*/function () {
 /*!***********************************!*\
   !*** ./lib/createDeferredTask.js ***!
   \***********************************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = createDeferredTask; /**
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* binding */ createDeferredTask)
+/* harmony export */ });
+/**
  * Create a deferred task that can be resolved when we call `resolve()`
  * The returned promise will complete when we call `resolve`
  * Useful when we want to wait for a tasks that is resolved from an external action
@@ -1715,8 +1764,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default
  * @returns {{ resolve: function(*), promise: Promise<T|void> }}
  */
 function createDeferredTask() {
-  var deferred = {};
-  deferred.promise = new Promise(function (res) {
+  const deferred = {};
+  deferred.promise = new Promise((res) => {
     deferred.resolve = res;
   });
 
@@ -1729,16 +1778,21 @@ function createDeferredTask() {
 /*!**************************!*\
   !*** ./lib/fastMerge.js ***!
   \**************************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0; // Mostly copied from https://medium.com/@lubaka.a/how-to-remove-lodash-performance-improvement-b306669ad0e1
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+// Mostly copied from https://medium.com/@lubaka.a/how-to-remove-lodash-performance-improvement-b306669ad0e1
 
 /**
  * @param {mixed} val
  * @returns {boolean}
 */
 function isMergeableObject(val) {
-  var nonNullObject = val != null ? typeof val === 'object' : false;
+  const nonNullObject = val != null ? typeof val === 'object' : false;
   return nonNullObject &&
   Object.prototype.toString.call(val) !== '[object RegExp]' &&
   Object.prototype.toString.call(val) !== '[object Date]';
@@ -1750,31 +1804,31 @@ function isMergeableObject(val) {
  * @returns {Object}
 */
 function mergeObject(target, source) {
-  var destination = {};
+  const destination = {};
   if (isMergeableObject(target)) {
     // lodash adds a small overhead so we don't use it here
     // eslint-disable-next-line rulesdir/prefer-underscore-method
-    var targetKeys = Object.keys(target);
-    for (var i = 0; i < targetKeys.length; ++i) {
-      var key = targetKeys[i];
+    const targetKeys = Object.keys(target);
+    for (let i = 0; i < targetKeys.length; ++i) {
+      const key = targetKeys[i];
       destination[key] = target[key];
     }
   }
 
   // lodash adds a small overhead so we don't use it here
   // eslint-disable-next-line rulesdir/prefer-underscore-method
-  var sourceKeys = Object.keys(source);
-  for (var _i = 0; _i < sourceKeys.length; ++_i) {
-    var _key = sourceKeys[_i];
-    if (source[_key] === undefined) {
+  const sourceKeys = Object.keys(source);
+  for (let i = 0; i < sourceKeys.length; ++i) {
+    const key = sourceKeys[i];
+    if (source[key] === undefined) {
       // eslint-disable-next-line no-continue
       continue;
     }
-    if (!isMergeableObject(source[_key]) || !target[_key]) {
-      destination[_key] = source[_key];
+    if (!isMergeableObject(source[key]) || !target[key]) {
+      destination[key] = source[key];
     } else {
       // eslint-disable-next-line no-use-before-define
-      destination[_key] = fastMerge(target[_key], source[_key]);
+      destination[key] = fastMerge(target[key], source[key]);
     }
   }
 
@@ -1789,14 +1843,14 @@ function mergeObject(target, source) {
 function fastMerge(target, source) {
   // lodash adds a small overhead so we don't use it here
   // eslint-disable-next-line rulesdir/prefer-underscore-method
-  var array = Array.isArray(source);
+  const array = Array.isArray(source);
   if (array) {
     return source;
   }
   return mergeObject(target, source);
-}var _default =
+}
 
-fastMerge;exports["default"] = _default;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (fastMerge);
 
 /***/ }),
 
@@ -1804,12 +1858,22 @@ fastMerge;exports["default"] = _default;
 /*!*****************************************!*\
   !*** ./lib/metrics/PerformanceUtils.js ***!
   \*****************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "logSetStateCall": () => (/* binding */ logSetStateCall),
+/* harmony export */   "setShouldDebugSetState": () => (/* binding */ setShouldDebugSetState)
+/* harmony export */ });
+/* harmony import */ var lodash_transform__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash/transform */ "lodash/transform");
+/* harmony import */ var lodash_transform__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash_transform__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_1__);
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports.logSetStateCall = logSetStateCall;exports.setShouldDebugSetState = setShouldDebugSetState;var _transform = _interopRequireDefault(__webpack_require__(/*! lodash/transform */ "lodash/transform"));
-var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
 
-var debugSetState = false;
+
+let debugSetState = false;
 
 /**
  * @param {Boolean} debug
@@ -1828,13 +1892,13 @@ function setShouldDebugSetState(debug) {
  */
 function diffObject(object, base) {
   function changes(obj, comparisonObject) {
-    return (0, _transform.default)(obj, function (result, value, key) {
-      if (_underscore.default.isEqual(value, comparisonObject[key])) {
+    return lodash_transform__WEBPACK_IMPORTED_MODULE_0___default()(obj, (result, value, key) => {
+      if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isEqual(value, comparisonObject[key])) {
         return;
       }
 
       // eslint-disable-next-line no-param-reassign
-      result[key] = _underscore.default.isObject(value) && _underscore.default.isObject(comparisonObject[key]) ?
+      result[key] = underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(value) && underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(comparisonObject[key]) ?
       changes(value, comparisonObject[key]) :
       value;
     });
@@ -1856,54 +1920,74 @@ function logSetStateCall(mapping, previousValue, newValue, caller, keyThatChange
     return;
   }
 
-  var logParams = {};
+  const logParams = {};
   if (keyThatChanged) {
     logParams.keyThatChanged = keyThatChanged;
   }
-  if (_underscore.default.isObject(newValue) && _underscore.default.isObject(previousValue)) {
+  if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(newValue) && underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(previousValue)) {
     logParams.difference = diffObject(previousValue, newValue);
   } else {
     logParams.previousValue = previousValue;
     logParams.newValue = newValue;
   }
 
-  console.debug("[Onyx-Debug] " + mapping.displayName + " setState() called. Subscribed to key '" + mapping.key + "' (" + caller + ")", logParams);
+  console.debug(`[Onyx-Debug] ${mapping.displayName} setState() called. Subscribed to key '${mapping.key}' (${caller})`, logParams);
 }
 
+
+
 /***/ }),
 
 /***/ "./lib/metrics/index.web.js":
 /*!**********************************!*\
   !*** ./lib/metrics/index.web.js ***!
   \**********************************/
-/***/ ((__unused_webpack_module, exports) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-Object.defineProperty(exports, "__esModule", ({ value: true }));exports.decorateWithMetrics = decorateWithMetrics;exports.getMetrics = getMetrics;exports.printMetrics = printMetrics;exports.resetMetrics = resetMetrics; // For web-only implementations of Onyx, this module will just be a no-op
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "decorateWithMetrics": () => (/* binding */ decorateWithMetrics),
+/* harmony export */   "getMetrics": () => (/* binding */ getMetrics),
+/* harmony export */   "printMetrics": () => (/* binding */ printMetrics),
+/* harmony export */   "resetMetrics": () => (/* binding */ resetMetrics)
+/* harmony export */ });
+// For web-only implementations of Onyx, this module will just be a no-op
 
 function decorateWithMetrics(func) {return func;}
 function getMetrics() {}
 function printMetrics() {}
 function resetMetrics() {}
 
+
+
 /***/ }),
 
 /***/ "./lib/storage/WebStorage.js":
 /*!***********************************!*\
   !*** ./lib/storage/WebStorage.js ***!
   \***********************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./providers/LocalForage */ "./lib/storage/providers/LocalForage.js");
+/**
+ * This file is here to wrap LocalForage with a layer that provides data-changed events like the ones that exist
+ * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
+ * data changes and then stay up-to-date with everything happening in Onyx.
+ */
 
 
 
+const SYNC_ONYX = 'SYNC_ONYX';
 
-var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
-var _LocalForage = _interopRequireDefault(__webpack_require__(/*! ./providers/LocalForage */ "./lib/storage/providers/LocalForage.js")); /**
- * This file is here to wrap LocalForage with a layer that provides data-changed events like the ones that exist
- * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
- * data changes and then stay up-to-date with everything happening in Onyx.
- */var SYNC_ONYX = 'SYNC_ONYX'; /**
+/**
  * Raise an event thorough `localStorage` to let other tabs know a value changed
  * @param {String} onyxKey
  */
@@ -1912,54 +1996,54 @@ function raiseStorageSyncEvent(onyxKey) {
   __webpack_require__.g.localStorage.removeItem(SYNC_ONYX, onyxKey);
 }
 
-var webStorage = Object.assign({},
-_LocalForage.default, {
+const webStorage = {
+  ..._providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__["default"],
 
   /**
    * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
    */
-  keepInstancesSync: function keepInstancesSync(onStorageKeyChanged) {
+  keepInstancesSync(onStorageKeyChanged) {
     // Override set, remove and clear to raise storage events that we intercept in other tabs
-    this.setItem = function (key, value) {return _LocalForage.default.setItem(key, value).
-      then(function () {return raiseStorageSyncEvent(key);});};
+    this.setItem = (key, value) => _providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__["default"].setItem(key, value).
+    then(() => raiseStorageSyncEvent(key));
 
-    this.removeItem = function (key) {return _LocalForage.default.removeItem(key).
-      then(function () {return raiseStorageSyncEvent(key);});};
+    this.removeItem = (key) => _providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__["default"].removeItem(key).
+    then(() => raiseStorageSyncEvent(key));
 
     // If we just call Storage.clear other tabs will have no idea which keys were available previously
     // so that they can call keysChanged for them. That's why we iterate over every key and raise a storage sync
     // event for each one
-    this.clear = function () {
-      var allKeys;
+    this.clear = () => {
+      let allKeys;
 
       // They keys must be retreived before storage is cleared or else the list of keys would be empty
-      return _LocalForage.default.getAllKeys().
-      then(function (keys) {
+      return _providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__["default"].getAllKeys().
+      then((keys) => {
         allKeys = keys;
       }).
-      then(function () {return _LocalForage.default.clear();}).
-      then(function () {
+      then(() => _providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__["default"].clear()).
+      then(() => {
         // Now that storage is cleared, the storage sync event can happen which is a more atomic action
         // for other browser tabs
-        _underscore.default.each(allKeys, raiseStorageSyncEvent);
+        underscore__WEBPACK_IMPORTED_MODULE_0___default().each(allKeys, raiseStorageSyncEvent);
       });
     };
 
     // This listener will only be triggered by events coming from other tabs
-    __webpack_require__.g.addEventListener('storage', function (event) {
+    __webpack_require__.g.addEventListener('storage', (event) => {
       // Ignore events that don't originate from the SYNC_ONYX logic
       if (event.key !== SYNC_ONYX || !event.newValue) {
         return;
       }
 
-      var onyxKey = event.newValue;
-      _LocalForage.default.getItem(onyxKey).
-      then(function (value) {return onStorageKeyChanged(onyxKey, value);});
+      const onyxKey = event.newValue;
+      _providers_LocalForage__WEBPACK_IMPORTED_MODULE_1__["default"].getItem(onyxKey).
+      then((value) => onStorageKeyChanged(onyxKey, value));
     });
-  } });var _default =
-
+  }
+};
 
-webStorage;exports["default"] = _default;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (webStorage);
 
 /***/ }),
 
@@ -1967,11 +2051,17 @@ webStorage;exports["default"] = _default;
 /*!**********************************!*\
   !*** ./lib/storage/index.web.js ***!
   \**********************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _WebStorage__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./WebStorage */ "./lib/storage/WebStorage.js");
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;var _WebStorage = _interopRequireDefault(__webpack_require__(/*! ./WebStorage */ "./lib/storage/WebStorage.js"));var _default =
 
-_WebStorage.default;exports["default"] = _default;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_WebStorage__WEBPACK_IMPORTED_MODULE_0__["default"]);
 
 /***/ }),
 
@@ -1979,44 +2069,55 @@ _WebStorage.default;exports["default"] = _default;
 /*!**********************************************!*\
   !*** ./lib/storage/providers/LocalForage.js ***!
   \**********************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;var _slicedToArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/slicedToArray */ "./node_modules/@babel/runtime/helpers/slicedToArray.js"));
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var localforage__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! localforage */ "localforage");
+/* harmony import */ var localforage__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(localforage__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _SyncQueue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../SyncQueue */ "./lib/SyncQueue.js");
+/* harmony import */ var _fastMerge__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../fastMerge */ "./lib/fastMerge.js");
+/**
+ * @file
+ * The storage provider based on localforage allows us to store most anything in its
+ * natural form in the underlying DB without having to stringify or de-stringify it
+ */
 
 
 
 
 
-var _localforage = _interopRequireDefault(__webpack_require__(/*! localforage */ "localforage"));
-var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
-var _SyncQueue = _interopRequireDefault(__webpack_require__(/*! ../../SyncQueue */ "./lib/SyncQueue.js"));
-var _fastMerge = _interopRequireDefault(__webpack_require__(/*! ../../fastMerge */ "./lib/fastMerge.js")); /**
- * @file
- * The storage provider based on localforage allows us to store most anything in its
- * natural form in the underlying DB without having to stringify or de-stringify it
- */_localforage.default.config({ name: 'OnyxDB' });
 
-var provider = {
+localforage__WEBPACK_IMPORTED_MODULE_0___default().config({
+  name: 'OnyxDB'
+});
+
+const provider = {
   /**
    * Writing very quickly to IndexedDB causes performance issues and can lock up the page and lead to jank.
    * So, we are slowing this process down by waiting until one write is complete before moving on
    * to the next.
    */
-  setItemQueue: new _SyncQueue.default(function (_ref) {var key = _ref.key,value = _ref.value,shouldMerge = _ref.shouldMerge;
+  setItemQueue: new _SyncQueue__WEBPACK_IMPORTED_MODULE_2__["default"]((_ref) => {let { key, value, shouldMerge } = _ref;
     if (shouldMerge) {
-      return _localforage.default.getItem(key).
-      then(function (existingValue) {
-        var newValue = _underscore.default.isObject(existingValue)
+      return localforage__WEBPACK_IMPORTED_MODULE_0___default().getItem(key).
+      then((existingValue) => {
+        const newValue = underscore__WEBPACK_IMPORTED_MODULE_1___default().isObject(existingValue)
 
         // lodash adds a small overhead so we don't use it here
         // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
-        ? Object.assign({}, (0, _fastMerge.default)(existingValue, value)) :
+        ? Object.assign({}, (0,_fastMerge__WEBPACK_IMPORTED_MODULE_3__["default"])(existingValue, value)) :
         value;
-        return _localforage.default.setItem(key, newValue);
+        return localforage__WEBPACK_IMPORTED_MODULE_0___default().setItem(key, newValue);
       });
     }
 
-    return _localforage.default.setItem(key, value);
+    return localforage__WEBPACK_IMPORTED_MODULE_0___default().setItem(key, value);
   }),
 
   /**
@@ -2024,11 +2125,11 @@ var provider = {
    * @param {String[]} keys
    * @return {Promise<Array<[key, value]>>}
    */
-  multiGet: function multiGet(keys) {
-    var pairs = _underscore.default.map(
+  multiGet(keys) {
+    const pairs = underscore__WEBPACK_IMPORTED_MODULE_1___default().map(
     keys,
-    function (key) {return _localforage.default.getItem(key).
-      then(function (value) {return [key, value];});});
+    (key) => localforage__WEBPACK_IMPORTED_MODULE_0___default().getItem(key).
+    then((value) => [key, value]));
 
 
     return Promise.all(pairs);
@@ -2039,11 +2140,11 @@ var provider = {
    * @param {Array<[key, value]>} pairs
    * @return {Promise<void>}
    */
-  multiMerge: function multiMerge(pairs) {var _this = this;
-    var tasks = _underscore.default.map(pairs, function (_ref2) {var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),key = _ref3[0],value = _ref3[1];return _this.setItemQueue.push({ key: key, value: value, shouldMerge: true });});
+  multiMerge(pairs) {
+    const tasks = underscore__WEBPACK_IMPORTED_MODULE_1___default().map(pairs, (_ref2) => {let [key, value] = _ref2;return this.setItemQueue.push({ key, value, shouldMerge: true });});
 
     // We're returning Promise.resolve, otherwise the array of task results will be returned to the caller
-    return Promise.all(tasks).then(function () {return Promise.resolve();});
+    return Promise.all(tasks).then(() => Promise.resolve());
   },
 
   /**
@@ -2051,40 +2152,40 @@ var provider = {
    * @param {Array<[key, value]>} pairs
    * @return {Promise<void>}
    */
-  multiSet: function multiSet(pairs) {var _this2 = this;
+  multiSet(pairs) {
     // We're returning Promise.resolve, otherwise the array of task results will be returned to the caller
-    var tasks = _underscore.default.map(pairs, function (_ref4) {var _ref5 = (0, _slicedToArray2.default)(_ref4, 2),key = _ref5[0],value = _ref5[1];return _this2.setItem(key, value);});
-    return Promise.all(tasks).then(function () {return Promise.resolve();});
+    const tasks = underscore__WEBPACK_IMPORTED_MODULE_1___default().map(pairs, (_ref3) => {let [key, value] = _ref3;return this.setItem(key, value);});
+    return Promise.all(tasks).then(() => Promise.resolve());
   },
 
   /**
    * Clear everything from storage and also stops the SyncQueue from adding anything more to storage
    * @returns {Promise<void>}
    */
-  clear: function clear() {
+  clear() {
     this.setItemQueue.abort();
-    return _localforage.default.clear();
+    return localforage__WEBPACK_IMPORTED_MODULE_0___default().clear();
   },
 
   /**
    * Returns all keys available in storage
    * @returns {Promise<String[]>}
    */
-  getAllKeys: _localforage.default.keys,
+  getAllKeys: (localforage__WEBPACK_IMPORTED_MODULE_0___default().keys),
 
   /**
    * Get the value of a given key or return `null` if it's not available in storage
    * @param {String} key
    * @return {Promise<*>}
    */
-  getItem: _localforage.default.getItem,
+  getItem: (localforage__WEBPACK_IMPORTED_MODULE_0___default().getItem),
 
   /**
    * Remove given key and it's value from storage
    * @param {String} key
    * @returns {Promise<void>}
    */
-  removeItem: _localforage.default.removeItem,
+  removeItem: (localforage__WEBPACK_IMPORTED_MODULE_0___default().removeItem),
 
   /**
    * Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
@@ -2092,12 +2193,12 @@ var provider = {
    * @param {*} value
    * @return {Promise<void>}
    */
-  setItem: function setItem(key, value) {
-    return this.setItemQueue.push({ key: key, value: value });
+  setItem(key, value) {
+    return this.setItemQueue.push({ key, value });
   }
-};var _default =
+};
 
-provider;exports["default"] = _default;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (provider);
 
 /***/ }),
 
@@ -2105,18 +2206,32 @@ provider;exports["default"] = _default;
 /*!*************************!*\
   !*** ./lib/withOnyx.js ***!
   \*************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! underscore */ "underscore");
+/* harmony import */ var underscore__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(underscore__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var prop_types__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! prop-types */ "./node_modules/prop-types/index.js");
+/* harmony import */ var prop_types__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(prop_types__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! expensify-common/lib/str */ "expensify-common/lib/str");
+/* harmony import */ var expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _Onyx__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Onyx */ "./lib/Onyx.js");
+function _extends() {_extends = Object.assign ? Object.assign.bind() : function (target) {for (var i = 1; i < arguments.length; i++) {var source = arguments[i];for (var key in source) {if (Object.prototype.hasOwnProperty.call(source, key)) {target[key] = source[key];}}}return target;};return _extends.apply(this, arguments);} /**
+ * This is a higher order component that provides the ability to map a state property directly to
+ * something in Onyx (a key/value store). That way, as soon as data in Onyx changes, the state will be set and the view
+ * will automatically change to reflect the new data.
+ */
 
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = _default;var _defineProperty2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/@babel/runtime/helpers/defineProperty.js"));var _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ "./node_modules/@babel/runtime/helpers/classCallCheck.js"));var _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ "./node_modules/@babel/runtime/helpers/createClass.js"));var _assertThisInitialized2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/assertThisInitialized */ "./node_modules/@babel/runtime/helpers/assertThisInitialized.js"));var _inherits2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/inherits */ "./node_modules/@babel/runtime/helpers/inherits.js"));var _possibleConstructorReturn2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ "./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js"));var _getPrototypeOf2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ "./node_modules/@babel/runtime/helpers/getPrototypeOf.js"));var _jsxRuntime = __webpack_require__(/*! react/jsx-runtime */ "./node_modules/react/jsx-runtime.js");
 
 
 
 
-var _react = _interopRequireDefault(__webpack_require__(/*! react */ "react"));
-var _underscore = _interopRequireDefault(__webpack_require__(/*! underscore */ "underscore"));
-var _propTypes = _interopRequireDefault(__webpack_require__(/*! prop-types */ "./node_modules/prop-types/index.js"));
-var _str = _interopRequireDefault(__webpack_require__(/*! expensify-common/lib/str */ "expensify-common/lib/str"));
-var _Onyx = _interopRequireDefault(__webpack_require__(/*! ./Onyx */ "./lib/Onyx.js"));var _jsxFileName = "/home/runner/work/react-native-onyx/react-native-onyx/lib/withOnyx.js";function _createSuper(Derived) {var hasNativeReflectConstruct = _isNativeReflectConstruct();return function _createSuperInternal() {var Super = (0, _getPrototypeOf2.default)(Derived),result;if (hasNativeReflectConstruct) {var NewTarget = (0, _getPrototypeOf2.default)(this).constructor;result = Reflect.construct(Super, arguments, NewTarget);} else {result = Super.apply(this, arguments);}return (0, _possibleConstructorReturn2.default)(this, result);};}function _isNativeReflectConstruct() {if (typeof Reflect === "undefined" || !Reflect.construct) return false;if (Reflect.construct.sham) return false;if (typeof Proxy === "function") return true;try {Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));return true;} catch (e) {return false;}}
 
 /**
  * Returns the display name of a component
@@ -2128,183 +2243,183 @@ function getDisplayName(component) {
   return component.displayName || component.name || 'Component';
 }
 
-function _default(mapOnyxToState) {var _this = this;
+/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(mapOnyxToState) {
   // A list of keys that must be present in tempState before we can render the WrappedComponent
-  var requiredKeysForInit = _underscore.default.chain(mapOnyxToState).
-  omit(function (config) {return config.initWithStoredValues === false;}).
+  const requiredKeysForInit = underscore__WEBPACK_IMPORTED_MODULE_1___default().chain(mapOnyxToState).
+  omit((config) => config.initWithStoredValues === false).
   keys().
   value();
-  return function (WrappedComponent) {
-    var displayName = getDisplayName(WrappedComponent);var
-    withOnyx = /*#__PURE__*/function (_React$Component) {(0, _inherits2.default)(withOnyx, _React$Component);var _super = _createSuper(withOnyx);
-      function withOnyx(props) {var _this2;(0, _classCallCheck2.default)(this, withOnyx);
-        _this2 = _super.call(this, props);
+  return (WrappedComponent) => {
+    const displayName = getDisplayName(WrappedComponent);
+    class withOnyx extends (react__WEBPACK_IMPORTED_MODULE_0___default().Component) {
+      constructor(props) {
+        super(props);
 
-        _this2.setWithOnyxState = _this2.setWithOnyxState.bind((0, _assertThisInitialized2.default)(_this2));
+        this.setWithOnyxState = this.setWithOnyxState.bind(this);
 
         // This stores all the Onyx connection IDs to be used when the component unmounts so everything can be
         // disconnected. It is a key value store with the format {[mapping.key]: connectionID}.
-        _this2.activeConnectionIDs = {};
+        this.activeConnectionIDs = {};
 
         // Object holding the temporary initial state for the component while we load the various Onyx keys
-        _this2.tempState = {};
+        this.tempState = {};
 
-        _this2.state = {
+        this.state = {
           // If there are no required keys for init then we can render the wrapped component immediately
           loading: requiredKeysForInit.length > 0
-        };return _this2;
-      }(0, _createClass2.default)(withOnyx, [{ key: "componentDidMount", value:
-
-        function componentDidMount() {var _this3 = this;
-          // Subscribe each of the state properties to the proper Onyx key
-          _underscore.default.each(mapOnyxToState, function (mapping, propertyName) {
-            _this3.connectMappingToOnyx(mapping, propertyName);
-          });
-          this.checkEvictableKeys();
-        } }, { key: "componentDidUpdate", value:
-
-        function componentDidUpdate(prevProps) {var _this4 = this;
-          // If any of the mappings use data from the props, then when the props change, all the
-          // connections need to be reconnected with the new props
-          _underscore.default.each(mapOnyxToState, function (mapping, propertyName) {
-            var previousKey = _str.default.result(mapping.key, prevProps);
-            var newKey = _str.default.result(mapping.key, _this4.props);
-
-            if (previousKey !== newKey) {
-              _Onyx.default.disconnect(_this4.activeConnectionIDs[previousKey], previousKey);
-              delete _this4.activeConnectionIDs[previousKey];
-              _this4.connectMappingToOnyx(mapping, propertyName);
-            }
-          });
-          this.checkEvictableKeys();
-        } }, { key: "componentWillUnmount", value:
-
-        function componentWillUnmount() {var _this5 = this;
-          // Disconnect everything from Onyx
-          _underscore.default.each(mapOnyxToState, function (mapping) {
-            var key = _str.default.result(mapping.key, _this5.props);
-            var connectionID = _this5.activeConnectionIDs[key];
-            _Onyx.default.disconnect(connectionID, key);
-          });
-        }
+        };
+      }
 
-        /**
-         * This method is used externally by sendDataToConnection to prevent unnecessary renders while a component
-         * still in a loading state. The temporary initial state is saved to the component instance and setState()
-         * only called once all the necessary data has been collected.
-         *
-         * @param {String} statePropertyName
-         * @param {*} val
-         */ }, { key: "setWithOnyxState", value:
-        function setWithOnyxState(statePropertyName, val) {var _this6 = this;
-          if (!this.state.loading) {
-            this.setState((0, _defineProperty2.default)({}, statePropertyName, val));
-            return;
-          }
+      componentDidMount() {
+        // Subscribe each of the state properties to the proper Onyx key
+        underscore__WEBPACK_IMPORTED_MODULE_1___default().each(mapOnyxToState, (mapping, propertyName) => {
+          this.connectMappingToOnyx(mapping, propertyName);
+        });
+        this.checkEvictableKeys();
+      }
 
-          this.tempState[statePropertyName] = val;
+      componentDidUpdate(prevProps) {
+        // If any of the mappings use data from the props, then when the props change, all the
+        // connections need to be reconnected with the new props
+        underscore__WEBPACK_IMPORTED_MODULE_1___default().each(mapOnyxToState, (mapping, propertyName) => {
+          const previousKey = expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default().result(mapping.key, prevProps);
+          const newKey = expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default().result(mapping.key, this.props);
 
-          // All state keys should exist and at least have a value of null
-          if (_underscore.default.some(requiredKeysForInit, function (key) {return _underscore.default.isUndefined(_this6.tempState[key]);})) {
-            return;
+          if (previousKey !== newKey) {
+            _Onyx__WEBPACK_IMPORTED_MODULE_4__["default"].disconnect(this.activeConnectionIDs[previousKey], previousKey);
+            delete this.activeConnectionIDs[previousKey];
+            this.connectMappingToOnyx(mapping, propertyName);
           }
+        });
+        this.checkEvictableKeys();
+      }
+
+      componentWillUnmount() {
+        // Disconnect everything from Onyx
+        underscore__WEBPACK_IMPORTED_MODULE_1___default().each(mapOnyxToState, (mapping) => {
+          const key = expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default().result(mapping.key, this.props);
+          const connectionID = this.activeConnectionIDs[key];
+          _Onyx__WEBPACK_IMPORTED_MODULE_4__["default"].disconnect(connectionID, key);
+        });
+      }
 
-          this.setState(Object.assign({}, this.tempState, { loading: false }));
-          delete this.tempState;
+      /**
+       * This method is used externally by sendDataToConnection to prevent unnecessary renders while a component
+       * still in a loading state. The temporary initial state is saved to the component instance and setState()
+       * only called once all the necessary data has been collected.
+       *
+       * @param {String} statePropertyName
+       * @param {*} val
+       */
+      setWithOnyxState(statePropertyName, val) {
+        if (!this.state.loading) {
+          this.setState({ [statePropertyName]: val });
+          return;
         }
 
-        /**
-         * Makes sure each Onyx key we requested has been set to state with a value of some kind.
-         * We are doing this so that the wrapped component will only render when all the data
-         * it needs is available to it.
-         */ }, { key: "checkEvictableKeys", value:
-        function checkEvictableKeys() {var _this7 = this;
-          // We will add this key to our list of recently accessed keys
-          // if the canEvict function returns true. This is necessary criteria
-          // we MUST use to specify if a key can be removed or not.
-          _underscore.default.each(mapOnyxToState, function (mapping) {
-            if (_underscore.default.isUndefined(mapping.canEvict)) {
-              return;
-            }
+        this.tempState[statePropertyName] = val;
 
-            var canEvict = _str.default.result(mapping.canEvict, _this7.props);
-            var key = _str.default.result(mapping.key, _this7.props);
+        // All state keys should exist and at least have a value of null
+        if (underscore__WEBPACK_IMPORTED_MODULE_1___default().some(requiredKeysForInit, (key) => underscore__WEBPACK_IMPORTED_MODULE_1___default().isUndefined(this.tempState[key]))) {
+          return;
+        }
 
-            if (!_Onyx.default.isSafeEvictionKey(key)) {
-              throw new Error("canEvict can't be used on key '" + key + "'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({safeEvictionKeys: []}).");
-            }
+        this.setState({ ...this.tempState, loading: false });
+        delete this.tempState;
+      }
+
+      /**
+       * Makes sure each Onyx key we requested has been set to state with a value of some kind.
+       * We are doing this so that the wrapped component will only render when all the data
+       * it needs is available to it.
+       */
+      checkEvictableKeys() {
+        // We will add this key to our list of recently accessed keys
+        // if the canEvict function returns true. This is necessary criteria
+        // we MUST use to specify if a key can be removed or not.
+        underscore__WEBPACK_IMPORTED_MODULE_1___default().each(mapOnyxToState, (mapping) => {
+          if (underscore__WEBPACK_IMPORTED_MODULE_1___default().isUndefined(mapping.canEvict)) {
+            return;
+          }
 
-            if (canEvict) {
-              _Onyx.default.removeFromEvictionBlockList(key, mapping.connectionID);
-            } else {
-              _Onyx.default.addToEvictionBlockList(key, mapping.connectionID);
-            }
-          });
-        }
+          const canEvict = expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default().result(mapping.canEvict, this.props);
+          const key = expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default().result(mapping.key, this.props);
 
-        /**
-         * Takes a single mapping and binds the state of the component to the store
-         *
-         * @param {object} mapping
-         * @param {string|function} mapping.key key to connect to. can be a string or a
-         * function that takes this.props as an argument and returns a string
-         * @param {string} statePropertyName the name of the state property that Onyx will add the data to
-         * @param {boolean} [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
-         *  component
-         */ }, { key: "connectMappingToOnyx", value:
-        function connectMappingToOnyx(mapping, statePropertyName) {
-          var key = _str.default.result(mapping.key, this.props);
-
-          // eslint-disable-next-line rulesdir/prefer-onyx-connect-in-libs
-          this.activeConnectionIDs[key] = _Onyx.default.connect(Object.assign({},
-          mapping, {
-            key: key,
-            statePropertyName: statePropertyName,
-            withOnyxInstance: this,
-            displayName: displayName }));
-
-        } }, { key: "render", value:
-
-        function render() {
-          if (this.state.loading) {
-            return null;
+          if (!_Onyx__WEBPACK_IMPORTED_MODULE_4__["default"].isSafeEvictionKey(key)) {
+            throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({safeEvictionKeys: []}).`);
+          }
+
+          if (canEvict) {
+            _Onyx__WEBPACK_IMPORTED_MODULE_4__["default"].removeFromEvictionBlockList(key, mapping.connectionID);
+          } else {
+            _Onyx__WEBPACK_IMPORTED_MODULE_4__["default"].addToEvictionBlockList(key, mapping.connectionID);
           }
+        });
+      }
 
-          // Remove any internal state properties used by withOnyx
-          // that should not be passed to a wrapped component
-          var stateToPass = _underscore.default.omit(this.state, 'loading');
-          stateToPass = _underscore.default.omit(stateToPass, function (value) {return _underscore.default.isNull(value);});
+      /**
+       * Takes a single mapping and binds the state of the component to the store
+       *
+       * @param {object} mapping
+       * @param {string|function} mapping.key key to connect to. can be a string or a
+       * function that takes this.props as an argument and returns a string
+       * @param {string} statePropertyName the name of the state property that Onyx will add the data to
+       * @param {boolean} [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
+       *  component
+       */
+      connectMappingToOnyx(mapping, statePropertyName) {
+        const key = expensify_common_lib_str__WEBPACK_IMPORTED_MODULE_3___default().result(mapping.key, this.props);
+
+        // eslint-disable-next-line rulesdir/prefer-onyx-connect-in-libs
+        this.activeConnectionIDs[key] = _Onyx__WEBPACK_IMPORTED_MODULE_4__["default"].connect({
+          ...mapping,
+          key,
+          statePropertyName,
+          withOnyxInstance: this,
+          displayName
+        });
+      }
+
+      render() {
+        if (this.state.loading) {
+          return null;
+        }
 
-          // Remove any null values so that React replaces them with default props
-          var propsToPass = _underscore.default.omit(this.props, function (value) {return _underscore.default.isNull(value);});
+        // Remove any internal state properties used by withOnyx
+        // that should not be passed to a wrapped component
+        let stateToPass = underscore__WEBPACK_IMPORTED_MODULE_1___default().omit(this.state, 'loading');
+        stateToPass = underscore__WEBPACK_IMPORTED_MODULE_1___default().omit(stateToPass, (value) => underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value));
 
-          // Spreading props and state is necessary in an HOC where the data cannot be predicted
-          return /*#__PURE__*/(
-            (0, _jsxRuntime.jsx)(WrappedComponent
-            // eslint-disable-next-line react/jsx-props-no-spreading
-            , Object.assign({}, propsToPass,
+        // Remove any null values so that React replaces them with default props
+        const propsToPass = underscore__WEBPACK_IMPORTED_MODULE_1___default().omit(this.props, (value) => underscore__WEBPACK_IMPORTED_MODULE_1___default().isNull(value));
 
-            stateToPass, {
-              ref: this.props.forwardedRef })));
+        // Spreading props and state is necessary in an HOC where the data cannot be predicted
+        return /*#__PURE__*/(
+          react__WEBPACK_IMPORTED_MODULE_0___default().createElement(WrappedComponent
+          // eslint-disable-next-line react/jsx-props-no-spreading
+          , _extends({}, propsToPass,
 
+          stateToPass, {
+            ref: this.props.forwardedRef })));
 
-        } }]);return withOnyx;}(_react.default.Component);
 
+      }
+    }
 
     withOnyx.propTypes = {
-      forwardedRef: _propTypes.default.oneOfType([
-      _propTypes.default.func,
-      _propTypes.default.shape({ current: _propTypes.default.instanceOf(_react.default.Component) })])
+      forwardedRef: prop_types__WEBPACK_IMPORTED_MODULE_2___default().oneOfType([
+      (prop_types__WEBPACK_IMPORTED_MODULE_2___default().func),
+      prop_types__WEBPACK_IMPORTED_MODULE_2___default().shape({ current: prop_types__WEBPACK_IMPORTED_MODULE_2___default().instanceOf((react__WEBPACK_IMPORTED_MODULE_0___default().Component)) })])
 
     };
     withOnyx.defaultProps = {
       forwardedRef: undefined
     };
-    withOnyx.displayName = "withOnyx(" + displayName + ")";
-    return _react.default.forwardRef(function (props, ref) {
-      var Component = withOnyx;
+    withOnyx.displayName = `withOnyx(${displayName})`;
+    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0___default().forwardRef((props, ref) => {
+      const Component = withOnyx;
       // eslint-disable-next-line react/jsx-props-no-spreading
-      return /*#__PURE__*/(0, _jsxRuntime.jsx)(Component, Object.assign({}, props, { forwardedRef: ref }));
+      return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0___default().createElement(Component, _extends({}, props, { forwardedRef: ref }));
     });
   };
 }
@@ -3383,1355 +3498,16 @@ if (false) {} else {
 
 /***/ }),
 
-/***/ "./node_modules/react/cjs/react-jsx-runtime.development.js":
-/*!*****************************************************************!*\
-  !*** ./node_modules/react/cjs/react-jsx-runtime.development.js ***!
-  \*****************************************************************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ "expensify-common/lib/str":
+/*!*******************************************!*\
+  !*** external "expensify-common/lib/str" ***!
+  \*******************************************/
+/***/ ((module) => {
 
 "use strict";
-/**
- * @license React
- * react-jsx-runtime.development.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
+module.exports = __WEBPACK_EXTERNAL_MODULE_expensify_common_lib_str__;
 
-
-if (true) {
-  (function() {
-'use strict';
-
-var React = __webpack_require__(/*! react */ "react");
-
-// -----------------------------------------------------------------------------
-
-var enableScopeAPI = false; // Experimental Create Event Handle API.
-var enableCacheElement = false;
-var enableTransitionTracing = false; // No known bugs, but needs performance testing
-
-var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
-// stuff. Intended to enable React core members to more easily debug scheduling
-// issues in DEV builds.
-
-var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
-
-// ATTENTION
-
-var REACT_ELEMENT_TYPE =  Symbol.for('react.element');
-var REACT_PORTAL_TYPE =  Symbol.for('react.portal');
-var REACT_FRAGMENT_TYPE =  Symbol.for('react.fragment');
-var REACT_STRICT_MODE_TYPE =  Symbol.for('react.strict_mode');
-var REACT_PROFILER_TYPE =  Symbol.for('react.profiler');
-var REACT_PROVIDER_TYPE =  Symbol.for('react.provider');
-var REACT_CONTEXT_TYPE =  Symbol.for('react.context');
-var REACT_FORWARD_REF_TYPE =  Symbol.for('react.forward_ref');
-var REACT_SUSPENSE_TYPE =  Symbol.for('react.suspense');
-var REACT_SUSPENSE_LIST_TYPE =  Symbol.for('react.suspense_list');
-var REACT_MEMO_TYPE =  Symbol.for('react.memo');
-var REACT_LAZY_TYPE =  Symbol.for('react.lazy');
-var REACT_OFFSCREEN_TYPE =  Symbol.for('react.offscreen');
-var MAYBE_ITERATOR_SYMBOL =  Symbol.iterator;
-var FAUX_ITERATOR_SYMBOL = '@@iterator';
-function getIteratorFn(maybeIterable) {
-  if (maybeIterable === null || typeof maybeIterable !== 'object') {
-    return null;
-  }
-
-  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
-
-  if (typeof maybeIterator === 'function') {
-    return maybeIterator;
-  }
-
-  return null;
-}
-
-var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-function error(format) {
-  {
-    {
-      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-        args[_key2 - 1] = arguments[_key2];
-      }
-
-      printWarning('error', format, args);
-    }
-  }
-}
-
-function printWarning(level, format, args) {
-  // When changing this logic, you might want to also
-  // update consoleWithStackDev.www.js as well.
-  {
-    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-    var stack = ReactDebugCurrentFrame.getStackAddendum();
-
-    if (stack !== '') {
-      format += '%s';
-      args = args.concat([stack]);
-    } // eslint-disable-next-line react-internal/safe-string-coercion
-
-
-    var argsWithFormat = args.map(function (item) {
-      return String(item);
-    }); // Careful: RN currently depends on this prefix
-
-    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
-    // breaks IE9: https://github.com/facebook/react/issues/13610
-    // eslint-disable-next-line react-internal/no-production-logging
-
-    Function.prototype.apply.call(console[level], console, argsWithFormat);
-  }
-}
-
-var REACT_MODULE_REFERENCE;
-
-{
-  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
-}
-
-function isValidElementType(type) {
-  if (typeof type === 'string' || typeof type === 'function') {
-    return true;
-  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
-
-
-  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
-    return true;
-  }
-
-  if (typeof type === 'object' && type !== null) {
-    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
-    // types supported by any Flight configuration anywhere since
-    // we don't know which Flight build this will end up being used
-    // with.
-    type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function getWrappedName(outerType, innerType, wrapperName) {
-  var displayName = outerType.displayName;
-
-  if (displayName) {
-    return displayName;
-  }
-
-  var functionName = innerType.displayName || innerType.name || '';
-  return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
-} // Keep in sync with react-reconciler/getComponentNameFromFiber
-
-
-function getContextName(type) {
-  return type.displayName || 'Context';
-} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
-
-
-function getComponentNameFromType(type) {
-  if (type == null) {
-    // Host root, text node or just invalid type.
-    return null;
-  }
-
-  {
-    if (typeof type.tag === 'number') {
-      error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
-    }
-  }
-
-  if (typeof type === 'function') {
-    return type.displayName || type.name || null;
-  }
-
-  if (typeof type === 'string') {
-    return type;
-  }
-
-  switch (type) {
-    case REACT_FRAGMENT_TYPE:
-      return 'Fragment';
-
-    case REACT_PORTAL_TYPE:
-      return 'Portal';
-
-    case REACT_PROFILER_TYPE:
-      return 'Profiler';
-
-    case REACT_STRICT_MODE_TYPE:
-      return 'StrictMode';
-
-    case REACT_SUSPENSE_TYPE:
-      return 'Suspense';
-
-    case REACT_SUSPENSE_LIST_TYPE:
-      return 'SuspenseList';
-
-  }
-
-  if (typeof type === 'object') {
-    switch (type.$$typeof) {
-      case REACT_CONTEXT_TYPE:
-        var context = type;
-        return getContextName(context) + '.Consumer';
-
-      case REACT_PROVIDER_TYPE:
-        var provider = type;
-        return getContextName(provider._context) + '.Provider';
-
-      case REACT_FORWARD_REF_TYPE:
-        return getWrappedName(type, type.render, 'ForwardRef');
-
-      case REACT_MEMO_TYPE:
-        var outerName = type.displayName || null;
-
-        if (outerName !== null) {
-          return outerName;
-        }
-
-        return getComponentNameFromType(type.type) || 'Memo';
-
-      case REACT_LAZY_TYPE:
-        {
-          var lazyComponent = type;
-          var payload = lazyComponent._payload;
-          var init = lazyComponent._init;
-
-          try {
-            return getComponentNameFromType(init(payload));
-          } catch (x) {
-            return null;
-          }
-        }
-
-      // eslint-disable-next-line no-fallthrough
-    }
-  }
-
-  return null;
-}
-
-var assign = Object.assign;
-
-// Helpers to patch console.logs to avoid logging during side-effect free
-// replaying on render function. This currently only patches the object
-// lazily which won't cover if the log function was extracted eagerly.
-// We could also eagerly patch the method.
-var disabledDepth = 0;
-var prevLog;
-var prevInfo;
-var prevWarn;
-var prevError;
-var prevGroup;
-var prevGroupCollapsed;
-var prevGroupEnd;
-
-function disabledLog() {}
-
-disabledLog.__reactDisabledLog = true;
-function disableLogs() {
-  {
-    if (disabledDepth === 0) {
-      /* eslint-disable react-internal/no-production-logging */
-      prevLog = console.log;
-      prevInfo = console.info;
-      prevWarn = console.warn;
-      prevError = console.error;
-      prevGroup = console.group;
-      prevGroupCollapsed = console.groupCollapsed;
-      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
-
-      var props = {
-        configurable: true,
-        enumerable: true,
-        value: disabledLog,
-        writable: true
-      }; // $FlowFixMe Flow thinks console is immutable.
-
-      Object.defineProperties(console, {
-        info: props,
-        log: props,
-        warn: props,
-        error: props,
-        group: props,
-        groupCollapsed: props,
-        groupEnd: props
-      });
-      /* eslint-enable react-internal/no-production-logging */
-    }
-
-    disabledDepth++;
-  }
-}
-function reenableLogs() {
-  {
-    disabledDepth--;
-
-    if (disabledDepth === 0) {
-      /* eslint-disable react-internal/no-production-logging */
-      var props = {
-        configurable: true,
-        enumerable: true,
-        writable: true
-      }; // $FlowFixMe Flow thinks console is immutable.
-
-      Object.defineProperties(console, {
-        log: assign({}, props, {
-          value: prevLog
-        }),
-        info: assign({}, props, {
-          value: prevInfo
-        }),
-        warn: assign({}, props, {
-          value: prevWarn
-        }),
-        error: assign({}, props, {
-          value: prevError
-        }),
-        group: assign({}, props, {
-          value: prevGroup
-        }),
-        groupCollapsed: assign({}, props, {
-          value: prevGroupCollapsed
-        }),
-        groupEnd: assign({}, props, {
-          value: prevGroupEnd
-        })
-      });
-      /* eslint-enable react-internal/no-production-logging */
-    }
-
-    if (disabledDepth < 0) {
-      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
-    }
-  }
-}
-
-var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
-var prefix;
-function describeBuiltInComponentFrame(name, source, ownerFn) {
-  {
-    if (prefix === undefined) {
-      // Extract the VM specific prefix used by each line.
-      try {
-        throw Error();
-      } catch (x) {
-        var match = x.stack.trim().match(/\n( *(at )?)/);
-        prefix = match && match[1] || '';
-      }
-    } // We use the prefix to ensure our stacks line up with native stack frames.
-
-
-    return '\n' + prefix + name;
-  }
-}
-var reentry = false;
-var componentFrameCache;
-
-{
-  var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
-  componentFrameCache = new PossiblyWeakMap();
-}
-
-function describeNativeComponentFrame(fn, construct) {
-  // If something asked for a stack inside a fake render, it should get ignored.
-  if ( !fn || reentry) {
-    return '';
-  }
-
-  {
-    var frame = componentFrameCache.get(fn);
-
-    if (frame !== undefined) {
-      return frame;
-    }
-  }
-
-  var control;
-  reentry = true;
-  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
-
-  Error.prepareStackTrace = undefined;
-  var previousDispatcher;
-
-  {
-    previousDispatcher = ReactCurrentDispatcher.current; // Set the dispatcher in DEV because this might be call in the render function
-    // for warnings.
-
-    ReactCurrentDispatcher.current = null;
-    disableLogs();
-  }
-
-  try {
-    // This should throw.
-    if (construct) {
-      // Something should be setting the props in the constructor.
-      var Fake = function () {
-        throw Error();
-      }; // $FlowFixMe
-
-
-      Object.defineProperty(Fake.prototype, 'props', {
-        set: function () {
-          // We use a throwing setter instead of frozen or non-writable props
-          // because that won't throw in a non-strict mode function.
-          throw Error();
-        }
-      });
-
-      if (typeof Reflect === 'object' && Reflect.construct) {
-        // We construct a different control for this case to include any extra
-        // frames added by the construct call.
-        try {
-          Reflect.construct(Fake, []);
-        } catch (x) {
-          control = x;
-        }
-
-        Reflect.construct(fn, [], Fake);
-      } else {
-        try {
-          Fake.call();
-        } catch (x) {
-          control = x;
-        }
-
-        fn.call(Fake.prototype);
-      }
-    } else {
-      try {
-        throw Error();
-      } catch (x) {
-        control = x;
-      }
-
-      fn();
-    }
-  } catch (sample) {
-    // This is inlined manually because closure doesn't do it for us.
-    if (sample && control && typeof sample.stack === 'string') {
-      // This extracts the first frame from the sample that isn't also in the control.
-      // Skipping one frame that we assume is the frame that calls the two.
-      var sampleLines = sample.stack.split('\n');
-      var controlLines = control.stack.split('\n');
-      var s = sampleLines.length - 1;
-      var c = controlLines.length - 1;
-
-      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
-        // We expect at least one stack frame to be shared.
-        // Typically this will be the root most one. However, stack frames may be
-        // cut off due to maximum stack limits. In this case, one maybe cut off
-        // earlier than the other. We assume that the sample is longer or the same
-        // and there for cut off earlier. So we should find the root most frame in
-        // the sample somewhere in the control.
-        c--;
-      }
-
-      for (; s >= 1 && c >= 0; s--, c--) {
-        // Next we find the first one that isn't the same which should be the
-        // frame that called our sample function and the control.
-        if (sampleLines[s] !== controlLines[c]) {
-          // In V8, the first line is describing the message but other VMs don't.
-          // If we're about to return the first line, and the control is also on the same
-          // line, that's a pretty good indicator that our sample threw at same line as
-          // the control. I.e. before we entered the sample frame. So we ignore this result.
-          // This can happen if you passed a class to function component, or non-function.
-          if (s !== 1 || c !== 1) {
-            do {
-              s--;
-              c--; // We may still have similar intermediate frames from the construct call.
-              // The next one that isn't the same should be our match though.
-
-              if (c < 0 || sampleLines[s] !== controlLines[c]) {
-                // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
-                var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
-                // but we have a user-provided "displayName"
-                // splice it in to make the stack more readable.
-
-
-                if (fn.displayName && _frame.includes('<anonymous>')) {
-                  _frame = _frame.replace('<anonymous>', fn.displayName);
-                }
-
-                {
-                  if (typeof fn === 'function') {
-                    componentFrameCache.set(fn, _frame);
-                  }
-                } // Return the line we found.
-
-
-                return _frame;
-              }
-            } while (s >= 1 && c >= 0);
-          }
-
-          break;
-        }
-      }
-    }
-  } finally {
-    reentry = false;
-
-    {
-      ReactCurrentDispatcher.current = previousDispatcher;
-      reenableLogs();
-    }
-
-    Error.prepareStackTrace = previousPrepareStackTrace;
-  } // Fallback to just using the name if we couldn't make it throw.
-
-
-  var name = fn ? fn.displayName || fn.name : '';
-  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
-
-  {
-    if (typeof fn === 'function') {
-      componentFrameCache.set(fn, syntheticFrame);
-    }
-  }
-
-  return syntheticFrame;
-}
-function describeFunctionComponentFrame(fn, source, ownerFn) {
-  {
-    return describeNativeComponentFrame(fn, false);
-  }
-}
-
-function shouldConstruct(Component) {
-  var prototype = Component.prototype;
-  return !!(prototype && prototype.isReactComponent);
-}
-
-function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
-
-  if (type == null) {
-    return '';
-  }
-
-  if (typeof type === 'function') {
-    {
-      return describeNativeComponentFrame(type, shouldConstruct(type));
-    }
-  }
-
-  if (typeof type === 'string') {
-    return describeBuiltInComponentFrame(type);
-  }
-
-  switch (type) {
-    case REACT_SUSPENSE_TYPE:
-      return describeBuiltInComponentFrame('Suspense');
-
-    case REACT_SUSPENSE_LIST_TYPE:
-      return describeBuiltInComponentFrame('SuspenseList');
-  }
-
-  if (typeof type === 'object') {
-    switch (type.$$typeof) {
-      case REACT_FORWARD_REF_TYPE:
-        return describeFunctionComponentFrame(type.render);
-
-      case REACT_MEMO_TYPE:
-        // Memo may contain any component type so we recursively resolve it.
-        return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
-
-      case REACT_LAZY_TYPE:
-        {
-          var lazyComponent = type;
-          var payload = lazyComponent._payload;
-          var init = lazyComponent._init;
-
-          try {
-            // Lazy may contain any component type so we recursively resolve it.
-            return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
-          } catch (x) {}
-        }
-    }
-  }
-
-  return '';
-}
-
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-var loggedTypeFailures = {};
-var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-
-function setCurrentlyValidatingElement(element) {
-  {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
-      ReactDebugCurrentFrame.setExtraStackFrame(stack);
-    } else {
-      ReactDebugCurrentFrame.setExtraStackFrame(null);
-    }
-  }
-}
-
-function checkPropTypes(typeSpecs, values, location, componentName, element) {
-  {
-    // $FlowFixMe This is okay but Flow doesn't know it.
-    var has = Function.call.bind(hasOwnProperty);
-
-    for (var typeSpecName in typeSpecs) {
-      if (has(typeSpecs, typeSpecName)) {
-        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
-        // fail the render phase where it didn't fail before. So we log it.
-        // After these have been cleaned up, we'll let them throw.
-
-        try {
-          // This is intentionally an invariant that gets caught. It's the same
-          // behavior as without this statement except with a better message.
-          if (typeof typeSpecs[typeSpecName] !== 'function') {
-            // eslint-disable-next-line react-internal/prod-error-codes
-            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
-            err.name = 'Invariant Violation';
-            throw err;
-          }
-
-          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
-        } catch (ex) {
-          error$1 = ex;
-        }
-
-        if (error$1 && !(error$1 instanceof Error)) {
-          setCurrentlyValidatingElement(element);
-
-          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
-
-          setCurrentlyValidatingElement(null);
-        }
-
-        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
-          // Only monitor this failure once because there tends to be a lot of the
-          // same error.
-          loggedTypeFailures[error$1.message] = true;
-          setCurrentlyValidatingElement(element);
-
-          error('Failed %s type: %s', location, error$1.message);
-
-          setCurrentlyValidatingElement(null);
-        }
-      }
-    }
-  }
-}
-
-var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
-
-function isArray(a) {
-  return isArrayImpl(a);
-}
-
-/*
- * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
- * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
- *
- * The functions in this module will throw an easier-to-understand,
- * easier-to-debug exception with a clear errors message message explaining the
- * problem. (Instead of a confusing exception thrown inside the implementation
- * of the `value` object).
- */
-// $FlowFixMe only called in DEV, so void return is not possible.
-function typeName(value) {
-  {
-    // toStringTag is needed for namespaced types like Temporal.Instant
-    var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
-    var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
-    return type;
-  }
-} // $FlowFixMe only called in DEV, so void return is not possible.
-
-
-function willCoercionThrow(value) {
-  {
-    try {
-      testStringCoercion(value);
-      return false;
-    } catch (e) {
-      return true;
-    }
-  }
-}
-
-function testStringCoercion(value) {
-  // If you ended up here by following an exception call stack, here's what's
-  // happened: you supplied an object or symbol value to React (as a prop, key,
-  // DOM attribute, CSS property, string ref, etc.) and when React tried to
-  // coerce it to a string using `'' + value`, an exception was thrown.
-  //
-  // The most common types that will cause this exception are `Symbol` instances
-  // and Temporal objects like `Temporal.Instant`. But any object that has a
-  // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
-  // exception. (Library authors do this to prevent users from using built-in
-  // numeric operators like `+` or comparison operators like `>=` because custom
-  // methods are needed to perform accurate arithmetic or comparison.)
-  //
-  // To fix the problem, coerce this object or symbol value to a string before
-  // passing it to React. The most reliable way is usually `String(value)`.
-  //
-  // To find which value is throwing, check the browser or debugger console.
-  // Before this exception was thrown, there should be `console.error` output
-  // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
-  // problem and how that type was used: key, atrribute, input value prop, etc.
-  // In most cases, this console output also shows the component and its
-  // ancestor components where the exception happened.
-  //
-  // eslint-disable-next-line react-internal/safe-string-coercion
-  return '' + value;
-}
-function checkKeyStringCoercion(value) {
-  {
-    if (willCoercionThrow(value)) {
-      error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
-
-      return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
-    }
-  }
-}
-
-var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
-var RESERVED_PROPS = {
-  key: true,
-  ref: true,
-  __self: true,
-  __source: true
-};
-var specialPropKeyWarningShown;
-var specialPropRefWarningShown;
-var didWarnAboutStringRefs;
-
-{
-  didWarnAboutStringRefs = {};
-}
-
-function hasValidRef(config) {
-  {
-    if (hasOwnProperty.call(config, 'ref')) {
-      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
-
-      if (getter && getter.isReactWarning) {
-        return false;
-      }
-    }
-  }
-
-  return config.ref !== undefined;
-}
-
-function hasValidKey(config) {
-  {
-    if (hasOwnProperty.call(config, 'key')) {
-      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
-
-      if (getter && getter.isReactWarning) {
-        return false;
-      }
-    }
-  }
-
-  return config.key !== undefined;
-}
-
-function warnIfStringRefCannotBeAutoConverted(config, self) {
-  {
-    if (typeof config.ref === 'string' && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
-      var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
-
-      if (!didWarnAboutStringRefs[componentName]) {
-        error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
-
-        didWarnAboutStringRefs[componentName] = true;
-      }
-    }
-  }
-}
-
-function defineKeyPropWarningGetter(props, displayName) {
-  {
-    var warnAboutAccessingKey = function () {
-      if (!specialPropKeyWarningShown) {
-        specialPropKeyWarningShown = true;
-
-        error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
-      }
-    };
-
-    warnAboutAccessingKey.isReactWarning = true;
-    Object.defineProperty(props, 'key', {
-      get: warnAboutAccessingKey,
-      configurable: true
-    });
-  }
-}
-
-function defineRefPropWarningGetter(props, displayName) {
-  {
-    var warnAboutAccessingRef = function () {
-      if (!specialPropRefWarningShown) {
-        specialPropRefWarningShown = true;
-
-        error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
-      }
-    };
-
-    warnAboutAccessingRef.isReactWarning = true;
-    Object.defineProperty(props, 'ref', {
-      get: warnAboutAccessingRef,
-      configurable: true
-    });
-  }
-}
-/**
- * Factory method to create a new React element. This no longer adheres to
- * the class pattern, so do not use new to call it. Also, instanceof check
- * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
- * if something is a React Element.
- *
- * @param {*} type
- * @param {*} props
- * @param {*} key
- * @param {string|object} ref
- * @param {*} owner
- * @param {*} self A *temporary* helper to detect places where `this` is
- * different from the `owner` when React.createElement is called, so that we
- * can warn. We want to get rid of owner and replace string `ref`s with arrow
- * functions, and as long as `this` and owner are the same, there will be no
- * change in behavior.
- * @param {*} source An annotation object (added by a transpiler or otherwise)
- * indicating filename, line number, and/or other information.
- * @internal
- */
-
-
-var ReactElement = function (type, key, ref, self, source, owner, props) {
-  var element = {
-    // This tag allows us to uniquely identify this as a React Element
-    $$typeof: REACT_ELEMENT_TYPE,
-    // Built-in properties that belong on the element
-    type: type,
-    key: key,
-    ref: ref,
-    props: props,
-    // Record the component responsible for creating this element.
-    _owner: owner
-  };
-
-  {
-    // The validation flag is currently mutative. We put it on
-    // an external backing store so that we can freeze the whole object.
-    // This can be replaced with a WeakMap once they are implemented in
-    // commonly used development environments.
-    element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
-    // the validation flag non-enumerable (where possible, which should
-    // include every environment we run tests in), so the test framework
-    // ignores it.
-
-    Object.defineProperty(element._store, 'validated', {
-      configurable: false,
-      enumerable: false,
-      writable: true,
-      value: false
-    }); // self and source are DEV only properties.
-
-    Object.defineProperty(element, '_self', {
-      configurable: false,
-      enumerable: false,
-      writable: false,
-      value: self
-    }); // Two elements created in two different places should be considered
-    // equal for testing purposes and therefore we hide it from enumeration.
-
-    Object.defineProperty(element, '_source', {
-      configurable: false,
-      enumerable: false,
-      writable: false,
-      value: source
-    });
-
-    if (Object.freeze) {
-      Object.freeze(element.props);
-      Object.freeze(element);
-    }
-  }
-
-  return element;
-};
-/**
- * https://github.com/reactjs/rfcs/pull/107
- * @param {*} type
- * @param {object} props
- * @param {string} key
- */
-
-function jsxDEV(type, config, maybeKey, source, self) {
-  {
-    var propName; // Reserved names are extracted
-
-    var props = {};
-    var key = null;
-    var ref = null; // Currently, key can be spread in as a prop. This causes a potential
-    // issue if key is also explicitly declared (ie. <div {...props} key="Hi" />
-    // or <div key="Hi" {...props} /> ). We want to deprecate key spread,
-    // but as an intermediary step, we will use jsxDEV for everything except
-    // <div {...props} key="Hi" />, because we aren't currently able to tell if
-    // key is explicitly declared to be undefined or not.
-
-    if (maybeKey !== undefined) {
-      {
-        checkKeyStringCoercion(maybeKey);
-      }
-
-      key = '' + maybeKey;
-    }
-
-    if (hasValidKey(config)) {
-      {
-        checkKeyStringCoercion(config.key);
-      }
-
-      key = '' + config.key;
-    }
-
-    if (hasValidRef(config)) {
-      ref = config.ref;
-      warnIfStringRefCannotBeAutoConverted(config, self);
-    } // Remaining properties are added to a new props object
-
-
-    for (propName in config) {
-      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
-        props[propName] = config[propName];
-      }
-    } // Resolve default props
-
-
-    if (type && type.defaultProps) {
-      var defaultProps = type.defaultProps;
-
-      for (propName in defaultProps) {
-        if (props[propName] === undefined) {
-          props[propName] = defaultProps[propName];
-        }
-      }
-    }
-
-    if (key || ref) {
-      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
-
-      if (key) {
-        defineKeyPropWarningGetter(props, displayName);
-      }
-
-      if (ref) {
-        defineRefPropWarningGetter(props, displayName);
-      }
-    }
-
-    return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
-  }
-}
-
-var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
-var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
-
-function setCurrentlyValidatingElement$1(element) {
-  {
-    if (element) {
-      var owner = element._owner;
-      var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
-      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
-    } else {
-      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
-    }
-  }
-}
-
-var propTypesMisspellWarningShown;
-
-{
-  propTypesMisspellWarningShown = false;
-}
-/**
- * Verifies the object is a ReactElement.
- * See https://reactjs.org/docs/react-api.html#isvalidelement
- * @param {?object} object
- * @return {boolean} True if `object` is a ReactElement.
- * @final
- */
-
-
-function isValidElement(object) {
-  {
-    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
-  }
-}
-
-function getDeclarationErrorAddendum() {
-  {
-    if (ReactCurrentOwner$1.current) {
-      var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
-
-      if (name) {
-        return '\n\nCheck the render method of `' + name + '`.';
-      }
-    }
-
-    return '';
-  }
-}
-
-function getSourceInfoErrorAddendum(source) {
-  {
-    if (source !== undefined) {
-      var fileName = source.fileName.replace(/^.*[\\\/]/, '');
-      var lineNumber = source.lineNumber;
-      return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
-    }
-
-    return '';
-  }
-}
-/**
- * Warn if there's no key explicitly set on dynamic arrays of children or
- * object keys are not valid. This allows us to keep track of children between
- * updates.
- */
-
-
-var ownerHasKeyUseWarning = {};
-
-function getCurrentComponentErrorInfo(parentType) {
-  {
-    var info = getDeclarationErrorAddendum();
-
-    if (!info) {
-      var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
-
-      if (parentName) {
-        info = "\n\nCheck the top-level render call using <" + parentName + ">.";
-      }
-    }
-
-    return info;
-  }
-}
-/**
- * Warn if the element doesn't have an explicit key assigned to it.
- * This element is in an array. The array could grow and shrink or be
- * reordered. All children that haven't already been validated are required to
- * have a "key" property assigned to it. Error statuses are cached so a warning
- * will only be shown once.
- *
- * @internal
- * @param {ReactElement} element Element that requires a key.
- * @param {*} parentType element's parent's type.
- */
-
-
-function validateExplicitKey(element, parentType) {
-  {
-    if (!element._store || element._store.validated || element.key != null) {
-      return;
-    }
-
-    element._store.validated = true;
-    var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
-
-    if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
-      return;
-    }
-
-    ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
-    // property, it may be the creator of the child that's responsible for
-    // assigning it a key.
-
-    var childOwner = '';
-
-    if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
-      // Give the component that originally created this child.
-      childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
-    }
-
-    setCurrentlyValidatingElement$1(element);
-
-    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
-
-    setCurrentlyValidatingElement$1(null);
-  }
-}
-/**
- * Ensure that every element either is passed in a static location, in an
- * array with an explicit keys property defined, or in an object literal
- * with valid key property.
- *
- * @internal
- * @param {ReactNode} node Statically passed child of any type.
- * @param {*} parentType node's parent's type.
- */
-
-
-function validateChildKeys(node, parentType) {
-  {
-    if (typeof node !== 'object') {
-      return;
-    }
-
-    if (isArray(node)) {
-      for (var i = 0; i < node.length; i++) {
-        var child = node[i];
-
-        if (isValidElement(child)) {
-          validateExplicitKey(child, parentType);
-        }
-      }
-    } else if (isValidElement(node)) {
-      // This element was passed in a valid location.
-      if (node._store) {
-        node._store.validated = true;
-      }
-    } else if (node) {
-      var iteratorFn = getIteratorFn(node);
-
-      if (typeof iteratorFn === 'function') {
-        // Entry iterators used to provide implicit keys,
-        // but now we print a separate warning for them later.
-        if (iteratorFn !== node.entries) {
-          var iterator = iteratorFn.call(node);
-          var step;
-
-          while (!(step = iterator.next()).done) {
-            if (isValidElement(step.value)) {
-              validateExplicitKey(step.value, parentType);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-/**
- * Given an element, validate that its props follow the propTypes definition,
- * provided by the type.
- *
- * @param {ReactElement} element
- */
-
-
-function validatePropTypes(element) {
-  {
-    var type = element.type;
-
-    if (type === null || type === undefined || typeof type === 'string') {
-      return;
-    }
-
-    var propTypes;
-
-    if (typeof type === 'function') {
-      propTypes = type.propTypes;
-    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
-    // Inner props are checked in the reconciler.
-    type.$$typeof === REACT_MEMO_TYPE)) {
-      propTypes = type.propTypes;
-    } else {
-      return;
-    }
-
-    if (propTypes) {
-      // Intentionally inside to avoid triggering lazy initializers:
-      var name = getComponentNameFromType(type);
-      checkPropTypes(propTypes, element.props, 'prop', name, element);
-    } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
-      propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
-
-      var _name = getComponentNameFromType(type);
-
-      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
-    }
-
-    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
-      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
-    }
-  }
-}
-/**
- * Given a fragment, validate that it can only be provided with fragment props
- * @param {ReactElement} fragment
- */
-
-
-function validateFragmentProps(fragment) {
-  {
-    var keys = Object.keys(fragment.props);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-
-      if (key !== 'children' && key !== 'key') {
-        setCurrentlyValidatingElement$1(fragment);
-
-        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
-
-        setCurrentlyValidatingElement$1(null);
-        break;
-      }
-    }
-
-    if (fragment.ref !== null) {
-      setCurrentlyValidatingElement$1(fragment);
-
-      error('Invalid attribute `ref` supplied to `React.Fragment`.');
-
-      setCurrentlyValidatingElement$1(null);
-    }
-  }
-}
-
-function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
-  {
-    var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
-    // succeed and there will likely be errors in render.
-
-    if (!validType) {
-      var info = '';
-
-      if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
-        info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
-      }
-
-      var sourceInfo = getSourceInfoErrorAddendum(source);
-
-      if (sourceInfo) {
-        info += sourceInfo;
-      } else {
-        info += getDeclarationErrorAddendum();
-      }
-
-      var typeString;
-
-      if (type === null) {
-        typeString = 'null';
-      } else if (isArray(type)) {
-        typeString = 'array';
-      } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
-        typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
-        info = ' Did you accidentally export a JSX literal instead of a component?';
-      } else {
-        typeString = typeof type;
-      }
-
-      error('React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
-    }
-
-    var element = jsxDEV(type, props, key, source, self); // The result can be nullish if a mock or a custom function is used.
-    // TODO: Drop this when these are no longer allowed as the type argument.
-
-    if (element == null) {
-      return element;
-    } // Skip key warning if the type isn't valid since our key validation logic
-    // doesn't expect a non-string/function type and can throw confusing errors.
-    // We don't want exception behavior to differ between dev and prod.
-    // (Rendering will throw with a helpful message and as soon as the type is
-    // fixed, the key warnings will appear.)
-
-
-    if (validType) {
-      var children = props.children;
-
-      if (children !== undefined) {
-        if (isStaticChildren) {
-          if (isArray(children)) {
-            for (var i = 0; i < children.length; i++) {
-              validateChildKeys(children[i], type);
-            }
-
-            if (Object.freeze) {
-              Object.freeze(children);
-            }
-          } else {
-            error('React.jsx: Static children should always be an array. ' + 'You are likely explicitly calling React.jsxs or React.jsxDEV. ' + 'Use the Babel transform instead.');
-          }
-        } else {
-          validateChildKeys(children, type);
-        }
-      }
-    }
-
-    if (type === REACT_FRAGMENT_TYPE) {
-      validateFragmentProps(element);
-    } else {
-      validatePropTypes(element);
-    }
-
-    return element;
-  }
-} // These two functions exist to still get child warnings in dev
-// even with the prod transform. This means that jsxDEV is purely
-// opt-in behavior for better messages but that we won't stop
-// giving you warnings if you use production apis.
-
-function jsxWithValidationStatic(type, props, key) {
-  {
-    return jsxWithValidation(type, props, key, true);
-  }
-}
-function jsxWithValidationDynamic(type, props, key) {
-  {
-    return jsxWithValidation(type, props, key, false);
-  }
-}
-
-var jsx =  jsxWithValidationDynamic ; // we may want to special case jsxs internally to take advantage of static children.
-// for now we can ship identical prod functions
-
-var jsxs =  jsxWithValidationStatic ;
-
-exports.Fragment = REACT_FRAGMENT_TYPE;
-exports.jsx = jsx;
-exports.jsxs = jsxs;
-  })();
-}
-
-
-/***/ }),
-
-/***/ "./node_modules/react/jsx-runtime.js":
-/*!*******************************************!*\
-  !*** ./node_modules/react/jsx-runtime.js ***!
-  \*******************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-
-if (false) {} else {
-  module.exports = __webpack_require__(/*! ./cjs/react-jsx-runtime.development.js */ "./node_modules/react/cjs/react-jsx-runtime.development.js");
-}
-
-
-/***/ }),
-
-/***/ "expensify-common/lib/str":
-/*!*******************************************!*\
-  !*** external "expensify-common/lib/str" ***!
-  \*******************************************/
-/***/ ((module) => {
-
-"use strict";
-module.exports = __WEBPACK_EXTERNAL_MODULE_expensify_common_lib_str__;
-
-/***/ }),
+/***/ }),
 
 /***/ "fast-equals":
 /*!******************************!*\
@@ -4797,371 +3573,6 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_react__;
 "use strict";
 module.exports = __WEBPACK_EXTERNAL_MODULE_underscore__;
 
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/arrayLikeToArray.js":
-/*!*****************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/arrayLikeToArray.js ***!
-  \*****************************************************************/
-/***/ ((module) => {
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) {
-    arr2[i] = arr[i];
-  }
-  return arr2;
-}
-module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/arrayWithHoles.js":
-/*!***************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/arrayWithHoles.js ***!
-  \***************************************************************/
-/***/ ((module) => {
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js":
-/*!******************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js ***!
-  \******************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray.js */ "./node_modules/@babel/runtime/helpers/arrayLikeToArray.js");
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return arrayLikeToArray(arr);
-}
-module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/assertThisInitialized.js":
-/*!**********************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/assertThisInitialized.js ***!
-  \**********************************************************************/
-/***/ ((module) => {
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-  return self;
-}
-module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/classCallCheck.js":
-/*!***************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/classCallCheck.js ***!
-  \***************************************************************/
-/***/ ((module) => {
-
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/createClass.js":
-/*!************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/createClass.js ***!
-  \************************************************************/
-/***/ ((module) => {
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
-}
-module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/defineProperty.js":
-/*!***************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/defineProperty.js ***!
-  \***************************************************************/
-/***/ ((module) => {
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/getPrototypeOf.js":
-/*!***************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/getPrototypeOf.js ***!
-  \***************************************************************/
-/***/ ((module) => {
-
-function _getPrototypeOf(o) {
-  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  return _getPrototypeOf(o);
-}
-module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/inherits.js":
-/*!*********************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/inherits.js ***!
-  \*********************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var setPrototypeOf = __webpack_require__(/*! ./setPrototypeOf.js */ "./node_modules/@babel/runtime/helpers/setPrototypeOf.js");
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
-    }
-  });
-  Object.defineProperty(subClass, "prototype", {
-    writable: false
-  });
-  if (superClass) setPrototypeOf(subClass, superClass);
-}
-module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js":
-/*!**********************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/interopRequireDefault.js ***!
-  \**********************************************************************/
-/***/ ((module) => {
-
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {
-    "default": obj
-  };
-}
-module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/iterableToArray.js":
-/*!****************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/iterableToArray.js ***!
-  \****************************************************************/
-/***/ ((module) => {
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js":
-/*!*********************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js ***!
-  \*********************************************************************/
-/***/ ((module) => {
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-  if (_i == null) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _s, _e;
-  try {
-    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
-  }
-  return _arr;
-}
-module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/nonIterableRest.js":
-/*!****************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/nonIterableRest.js ***!
-  \****************************************************************/
-/***/ ((module) => {
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/nonIterableSpread.js":
-/*!******************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/nonIterableSpread.js ***!
-  \******************************************************************/
-/***/ ((module) => {
-
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js":
-/*!**************************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js ***!
-  \**************************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var _typeof = (__webpack_require__(/*! ./typeof.js */ "./node_modules/@babel/runtime/helpers/typeof.js")["default"]);
-var assertThisInitialized = __webpack_require__(/*! ./assertThisInitialized.js */ "./node_modules/@babel/runtime/helpers/assertThisInitialized.js");
-function _possibleConstructorReturn(self, call) {
-  if (call && (_typeof(call) === "object" || typeof call === "function")) {
-    return call;
-  } else if (call !== void 0) {
-    throw new TypeError("Derived constructors may only return object or undefined");
-  }
-  return assertThisInitialized(self);
-}
-module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/setPrototypeOf.js":
-/*!***************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/setPrototypeOf.js ***!
-  \***************************************************************/
-/***/ ((module) => {
-
-function _setPrototypeOf(o, p) {
-  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-  return _setPrototypeOf(o, p);
-}
-module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/slicedToArray.js":
-/*!**************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/slicedToArray.js ***!
-  \**************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var arrayWithHoles = __webpack_require__(/*! ./arrayWithHoles.js */ "./node_modules/@babel/runtime/helpers/arrayWithHoles.js");
-var iterableToArrayLimit = __webpack_require__(/*! ./iterableToArrayLimit.js */ "./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js");
-var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray.js */ "./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js");
-var nonIterableRest = __webpack_require__(/*! ./nonIterableRest.js */ "./node_modules/@babel/runtime/helpers/nonIterableRest.js");
-function _slicedToArray(arr, i) {
-  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
-}
-module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/toConsumableArray.js":
-/*!******************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/toConsumableArray.js ***!
-  \******************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var arrayWithoutHoles = __webpack_require__(/*! ./arrayWithoutHoles.js */ "./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js");
-var iterableToArray = __webpack_require__(/*! ./iterableToArray.js */ "./node_modules/@babel/runtime/helpers/iterableToArray.js");
-var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray.js */ "./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js");
-var nonIterableSpread = __webpack_require__(/*! ./nonIterableSpread.js */ "./node_modules/@babel/runtime/helpers/nonIterableSpread.js");
-function _toConsumableArray(arr) {
-  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
-}
-module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/typeof.js":
-/*!*******************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/typeof.js ***!
-  \*******************************************************/
-/***/ ((module) => {
-
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
-}
-module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
-/***/ }),
-
-/***/ "./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js":
-/*!***************************************************************************!*\
-  !*** ./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js ***!
-  \***************************************************************************/
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray.js */ "./node_modules/@babel/runtime/helpers/arrayLikeToArray.js");
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
-}
-module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
-
 /***/ })
 
 /******/ 	});
@@ -5191,6 +3602,30 @@ module.exports = _unsupportedIterableToArray, module.exports.__esModule = true,
 /******/ 	}
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/global */
 /******/ 	(() => {
 /******/ 		__webpack_require__.g = (function() {
@@ -5203,18 +3638,42 @@ module.exports = _unsupportedIterableToArray, module.exports.__esModule = true,
 /******/ 		})();
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
 (() => {
-var exports = __webpack_exports__;
+"use strict";
 /*!**********************!*\
   !*** ./lib/index.js ***!
   \**********************/
-var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/@babel/runtime/helpers/interopRequireDefault.js");Object.defineProperty(exports, "__esModule", ({ value: true }));exports["default"] = void 0;Object.defineProperty(exports, "withOnyx", ({ enumerable: true, get: function get() {return _withOnyx.default;} }));var _Onyx = _interopRequireDefault(__webpack_require__(/*! ./Onyx */ "./lib/Onyx.js"));
-var _withOnyx = _interopRequireDefault(__webpack_require__(/*! ./withOnyx */ "./lib/withOnyx.js"));var _default =
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   "withOnyx": () => (/* reexport safe */ _withOnyx__WEBPACK_IMPORTED_MODULE_1__["default"])
+/* harmony export */ });
+/* harmony import */ var _Onyx__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Onyx */ "./lib/Onyx.js");
+/* harmony import */ var _withOnyx__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./withOnyx */ "./lib/withOnyx.js");
+
+
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_Onyx__WEBPACK_IMPORTED_MODULE_0__["default"]);
 
-_Onyx.default;exports["default"] = _default;
 })();
 
 /******/ 	return __webpack_exports__;