@amazon-devices/react-navigation__routers 7.0.1759135970 → 8.0.9000000000-rn-83

package/SystemBundles/b6cc62e27d70be8722b0e7aef9fd04a870d49127e6c724fe934d1f8ca4ff8177.bundle

@@ -0,0 +1,1298 @@
+var __BUNDLE_START_TIME__=globalThis.nativePerformanceNow?nativePerformanceNow():Date.now(),__DEV__=false,process=globalThis.process||{},__METRO_GLOBAL_PREFIX__='';process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"production";
+(function (global) {
+  global._majorVersionToNoVersionIdMap["38c132d4a4bb76eedc80"] = "6cc26ebe1139d52af4d3";
+  global._majorVersionToNoVersionIdMap["4aa609d49dd4d9fd69d8"] = "32fd789b2b4e67ba3679";
+  global._majorVersionToNoVersionIdMap["6664264a195fd5e23d1d"] = "0060dd931905de8947f2";
+  global._majorVersionToNoVersionIdMap["ab2268e7375692a18adc"] = "2b770725127b9776e940";
+  global._majorVersionToNoVersionIdMap["2beefa0726d547efb6db"] = "b4b91107e9e069bf6a04";
+  global._majorVersionToNoVersionIdMap["cdf36facce344b18753d"] = "dec21c689e6604dbbf6a";
+  global._majorVersionToNoVersionIdMap["f37671f481d3442f7534"] = "1156635305634f3a14c7";
+  global._majorVersionToNoVersionIdMap["c69c3cb84fab85c7ab0e"] = "0308dce3623ba6fd6f70";
+  global._majorVersionToNoVersionIdMap["c39b5e831a38e3449d62"] = "38a8cc556e14fd685890";
+  global._majorVersionToNoVersionIdMap["88041ddd5b5dffda940e"] = "1b0b28afa5b685260b1d";
+  global._majorVersionToNoVersionIdMap["42552d18e7ae0181bd39"] = "2bee182fbe6f2aca641e";
+  global._majorVersionToNoVersionIdMap["bb57842acdb83f2b3f2e"] = "eb7d4baa35301f5aed5f";
+  global._majorVersionToNoVersionIdMap["b323020ab42ad72c3c32"] = "4d722edf544c9fdf1c6e";
+  global._majorVersionToNoVersionIdMap["9f3bb7c66a6d54b4f31f"] = "6770b45f91f2db97b2e2";
+  global._majorVersionToNoVersionIdMap["6b91947bdfabfe9f3fcb"] = "46404a6d49463f9601d3";
+  global._majorVersionToNoVersionIdMap["cd82459845fcc006200c"] = "cbb4d666ebd7ab852aa3";
+  global._majorVersionToNoVersionIdMap["8ef843d324cbf8ceac15"] = "06a5a1d28ce3fd05c417";
+  global._majorVersionToNoVersionIdMap["278cdd8bb8970d40410d"] = "fb17719fd282a08dfde9";
+  global._majorVersionToNoVersionIdMap["9bc9fe221ec0ce458468"] = "8b1e20a6232a353c9981";
+  global._majorVersionToNoVersionIdMap["e793a2a0d8af55b1360e"] = "5077535faaf552d97157";
+  global._majorVersionToNoVersionIdMap["130dabfd918c0cb9f581"] = "04f3f6928f15baafd43b";
+  global._majorVersionToNoVersionIdMap["bdff2caa69d04b792045"] = "39eca4bd16c398373cc4";
+  global._majorVersionToNoVersionIdMap["b0bba4cced4da2c7d68d"] = "347ca45e3641dd48caa1";
+})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  var _exportNames = {
+    CommonActions: true,
+    BaseRouter: true,
+    DrawerActions: true,
+    DrawerRouter: true,
+    StackActions: true,
+    StackRouter: true,
+    TabActions: true,
+    TabRouter: true
+  };
+  Object.defineProperty(exports, "BaseRouter", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[0]).BaseRouter;
+    }
+  });
+  exports.CommonActions = undefined;
+  Object.defineProperty(exports, "DrawerActions", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[1]).DrawerActions;
+    }
+  });
+  Object.defineProperty(exports, "DrawerRouter", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[1]).DrawerRouter;
+    }
+  });
+  Object.defineProperty(exports, "StackActions", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[2]).StackActions;
+    }
+  });
+  Object.defineProperty(exports, "StackRouter", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[2]).StackRouter;
+    }
+  });
+  Object.defineProperty(exports, "TabActions", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[3]).TabActions;
+    }
+  });
+  Object.defineProperty(exports, "TabRouter", {
+    enumerable: true,
+    get: function () {
+      return _$$_REQUIRE(_dependencyMap[3]).TabRouter;
+    }
+  });
+  var CommonActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4]));
+  exports.CommonActions = CommonActions;
+  Object.keys(_$$_REQUIRE(_dependencyMap[5])).forEach(function (key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    if (key in exports && exports[key] === _$$_REQUIRE(_dependencyMap[5])[key]) return;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      get: function () {
+        return _$$_REQUIRE(_dependencyMap[5])[key];
+      }
+    });
+  });
+  function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+},"c39b5e831a38e3449d62",["4aa609d49dd4d9fd69d8","ab2268e7375692a18adc","2beefa0726d547efb6db","cdf36facce344b18753d","6664264a195fd5e23d1d","42552d18e7ae0181bd39"]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.BaseRouter = undefined;
+  /**
+   * Base router object that can be used when writing custom routers.
+   * This provides few helper methods to handle common actions such as `RESET`.
+   */
+  var BaseRouter = exports.BaseRouter = {
+    getStateForAction(state, action) {
+      switch (action.type) {
+        case 'SET_PARAMS':
+        case 'REPLACE_PARAMS':
+          {
+            var index = action.source ? state.routes.findIndex(r => r.key === action.source) : state.index;
+            if (index === -1) {
+              return null;
+            }
+            return {
+              ...state,
+              routes: state.routes.map((r, i) => i === index ? {
+                ...r,
+                params: action.type === 'REPLACE_PARAMS' ? action.payload.params : {
+                  ...r.params,
+                  ...action.payload.params
+                }
+              } : r)
+            };
+          }
+        case 'RESET':
+          {
+            var nextState = action.payload;
+            if (nextState.routes.length === 0 || nextState.routes.some(route => !state.routeNames.includes(route.name))) {
+              return null;
+            }
+            if (nextState.stale === false) {
+              if (state.routeNames.length !== nextState.routeNames.length || nextState.routeNames.some(name => !state.routeNames.includes(name))) {
+                return null;
+              }
+              return {
+                ...nextState,
+                routes: nextState.routes.map(route => route.key ? route : {
+                  ...route,
+                  key: `${route.name}-${(0, _$$_REQUIRE(_dependencyMap[0]).nanoid)()}`
+                })
+              };
+            }
+            return nextState;
+          }
+        default:
+          return null;
+      }
+    },
+    shouldActionChangeFocus(action) {
+      return action.type === 'NAVIGATE' || action.type === 'NAVIGATE_DEPRECATED';
+    }
+  };
+},"4aa609d49dd4d9fd69d8",["f9dacdfad56c8f57acc2"]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.nanoid = exports.customAlphabet = undefined;
+  var urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+  var customAlphabet = (alphabet, defaultSize = 21) => {
+    return (size = defaultSize) => {
+      var id = '';
+      var i = size | 0;
+      while (i--) {
+        id += alphabet[Math.random() * alphabet.length | 0];
+      }
+      return id;
+    };
+  };
+  exports.customAlphabet = customAlphabet;
+  var nanoid = (size = 21) => {
+    var id = '';
+    var i = size | 0;
+    while (i--) {
+      id += urlAlphabet[Math.random() * 64 | 0];
+    }
+    return id;
+  };
+  exports.nanoid = nanoid;
+},"f9dacdfad56c8f57acc2",[]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.DrawerActions = undefined;
+  exports.DrawerRouter = DrawerRouter;
+  var DrawerActions = exports.DrawerActions = {
+    ..._$$_REQUIRE(_dependencyMap[0]).TabActions,
+    openDrawer() {
+      return {
+        type: 'OPEN_DRAWER'
+      };
+    },
+    closeDrawer() {
+      return {
+        type: 'CLOSE_DRAWER'
+      };
+    },
+    toggleDrawer() {
+      return {
+        type: 'TOGGLE_DRAWER'
+      };
+    }
+  };
+  function DrawerRouter({
+    defaultStatus = 'closed',
+    ...rest
+  }) {
+    var router = (0, _$$_REQUIRE(_dependencyMap[0]).TabRouter)(rest);
+    var isDrawerInHistory = state => Boolean(state.history?.some(it => it.type === 'drawer'));
+    var addDrawerToHistory = state => {
+      if (isDrawerInHistory(state)) {
+        return state;
+      }
+      return {
+        ...state,
+        history: [...state.history, {
+          type: 'drawer',
+          status: defaultStatus === 'open' ? 'closed' : 'open'
+        }]
+      };
+    };
+    var removeDrawerFromHistory = state => {
+      if (!isDrawerInHistory(state)) {
+        return state;
+      }
+      return {
+        ...state,
+        history: state.history.filter(it => it.type !== 'drawer')
+      };
+    };
+    var openDrawer = state => {
+      if (defaultStatus === 'open') {
+        return removeDrawerFromHistory(state);
+      }
+      return addDrawerToHistory(state);
+    };
+    var closeDrawer = state => {
+      if (defaultStatus === 'open') {
+        return addDrawerToHistory(state);
+      }
+      return removeDrawerFromHistory(state);
+    };
+    return {
+      ...router,
+      type: 'drawer',
+      getInitialState({
+        routeNames,
+        routeParamList,
+        routeGetIdList
+      }) {
+        var state = router.getInitialState({
+          routeNames,
+          routeParamList,
+          routeGetIdList
+        });
+        return {
+          ...state,
+          default: defaultStatus,
+          stale: false,
+          type: 'drawer',
+          key: `drawer-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`
+        };
+      },
+      getRehydratedState(partialState, {
+        routeNames,
+        routeParamList,
+        routeGetIdList
+      }) {
+        if (partialState.stale === false) {
+          return partialState;
+        }
+        var state = router.getRehydratedState(partialState, {
+          routeNames,
+          routeParamList,
+          routeGetIdList
+        });
+        if (isDrawerInHistory(partialState)) {
+          // Re-sync the drawer entry in history to correct it if it was wrong
+          state = removeDrawerFromHistory(state);
+          state = addDrawerToHistory(state);
+        }
+        return {
+          ...state,
+          default: defaultStatus,
+          type: 'drawer',
+          key: `drawer-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`
+        };
+      },
+      getStateForRouteFocus(state, key) {
+        var result = router.getStateForRouteFocus(state, key);
+        return closeDrawer(result);
+      },
+      getStateForAction(state, action, options) {
+        switch (action.type) {
+          case 'OPEN_DRAWER':
+            return openDrawer(state);
+          case 'CLOSE_DRAWER':
+            return closeDrawer(state);
+          case 'TOGGLE_DRAWER':
+            if (isDrawerInHistory(state)) {
+              return removeDrawerFromHistory(state);
+            }
+            return addDrawerToHistory(state);
+          case 'JUMP_TO':
+          case 'NAVIGATE':
+          case 'NAVIGATE_DEPRECATED':
+            {
+              var result = router.getStateForAction(state, action, options);
+              if (result != null && result.index !== state.index) {
+                return closeDrawer(result);
+              }
+              return result;
+            }
+          case 'GO_BACK':
+            if (isDrawerInHistory(state)) {
+              return removeDrawerFromHistory(state);
+            }
+            return router.getStateForAction(state, action, options);
+          default:
+            return router.getStateForAction(state, action, options);
+        }
+      },
+      actionCreators: DrawerActions
+    };
+  }
+},"ab2268e7375692a18adc",["cdf36facce344b18753d","f9dacdfad56c8f57acc2"]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.TabActions = undefined;
+  exports.TabRouter = TabRouter;
+  var TYPE_ROUTE = 'route';
+  var TabActions = exports.TabActions = {
+    jumpTo(name, params) {
+      return {
+        type: 'JUMP_TO',
+        payload: {
+          name,
+          params
+        }
+      };
+    }
+  };
+  var getRouteHistory = (routes, index, backBehavior, initialRouteName) => {
+    var history = [{
+      type: TYPE_ROUTE,
+      key: routes[index].key
+    }];
+    var initialRouteIndex;
+    switch (backBehavior) {
+      case 'order':
+        for (var i = index; i > 0; i--) {
+          history.unshift({
+            type: TYPE_ROUTE,
+            key: routes[i - 1].key
+          });
+        }
+        break;
+      case 'firstRoute':
+        if (index !== 0) {
+          history.unshift({
+            type: TYPE_ROUTE,
+            key: routes[0].key
+          });
+        }
+        break;
+      case 'initialRoute':
+        initialRouteIndex = routes.findIndex(route => route.name === initialRouteName);
+        initialRouteIndex = initialRouteIndex === -1 ? 0 : initialRouteIndex;
+        if (index !== initialRouteIndex) {
+          history.unshift({
+            type: TYPE_ROUTE,
+            key: routes[initialRouteIndex].key
+          });
+        }
+        break;
+      case 'history':
+      case 'fullHistory':
+        // The history will fill up on navigation
+        break;
+    }
+    return history;
+  };
+  var changeIndex = (state, index, backBehavior, initialRouteName) => {
+    var history = state.history;
+    if (backBehavior === 'history' || backBehavior === 'fullHistory') {
+      var currentRoute = state.routes[index];
+      if (backBehavior === 'history') {
+        // Remove the existing key from the history to de-duplicate it
+        history = history.filter(it => it.type === 'route' ? it.key !== currentRoute.key : false);
+      } else if (backBehavior === 'fullHistory') {
+        var lastHistoryRouteItemIndex = history.findLastIndex(item => item.type === 'route');
+        if (currentRoute.key === history[lastHistoryRouteItemIndex]?.key) {
+          // For full-history, only remove if it matches the last route
+          // Useful for drawer, if current route was in history, then drawer state changed
+          // Then we only need to move the route to the front
+          history = [...history.slice(0, lastHistoryRouteItemIndex), ...history.slice(lastHistoryRouteItemIndex + 1)];
+        }
+      }
+      history = history.concat({
+        type: TYPE_ROUTE,
+        key: currentRoute.key,
+        params: backBehavior === 'fullHistory' ? currentRoute.params : undefined
+      });
+    } else {
+      history = getRouteHistory(state.routes, index, backBehavior, initialRouteName);
+    }
+    return {
+      ...state,
+      index,
+      history
+    };
+  };
+  function TabRouter({
+    initialRouteName,
+    backBehavior = 'firstRoute'
+  }) {
+    var router = {
+      ..._$$_REQUIRE(_dependencyMap[0]).BaseRouter,
+      type: 'tab',
+      getInitialState({
+        routeNames,
+        routeParamList
+      }) {
+        var index = initialRouteName !== undefined && routeNames.includes(initialRouteName) ? routeNames.indexOf(initialRouteName) : 0;
+        var routes = routeNames.map(name => ({
+          name,
+          key: `${name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          params: routeParamList[name]
+        }));
+        var history = getRouteHistory(routes, index, backBehavior, initialRouteName);
+        return {
+          stale: false,
+          type: 'tab',
+          key: `tab-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          index,
+          routeNames,
+          history,
+          routes,
+          preloadedRouteKeys: []
+        };
+      },
+      getRehydratedState(partialState, {
+        routeNames,
+        routeParamList
+      }) {
+        var state = partialState;
+        if (state.stale === false) {
+          return state;
+        }
+        var routes = routeNames.map(name => {
+          var route = state.routes.find(r => r.name === name);
+          return {
+            ...route,
+            name,
+            key: route && route.name === name && route.key ? route.key : `${name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+            params: routeParamList[name] !== undefined ? {
+              ...routeParamList[name],
+              ...(route ? route.params : undefined)
+            } : route ? route.params : undefined
+          };
+        });
+        var index = Math.min(Math.max(routeNames.indexOf(state.routes[state?.index ?? 0]?.name), 0), routes.length - 1);
+        var routeKeys = routes.map(route => route.key);
+        var history = state.history?.filter(it => routeKeys.includes(it.key)) ?? [];
+        return changeIndex({
+          stale: false,
+          type: 'tab',
+          key: `tab-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          index,
+          routeNames,
+          history,
+          routes,
+          preloadedRouteKeys: state.preloadedRouteKeys?.filter(key => routeKeys.includes(key)) ?? []
+        }, index, backBehavior, initialRouteName);
+      },
+      getStateForRouteNamesChange(state, {
+        routeNames,
+        routeParamList,
+        routeKeyChanges
+      }) {
+        var routes = routeNames.map(name => state.routes.find(r => r.name === name && !routeKeyChanges.includes(r.name)) || {
+          name,
+          key: `${name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          params: routeParamList[name]
+        });
+        var index = Math.max(0, routeNames.indexOf(state.routes[state.index].name));
+        var history = state.history.filter(
+        // Type will always be 'route' for tabs, but could be different in a router extending this (e.g. drawer)
+        it => it.type !== 'route' || routes.find(r => r.key === it.key));
+        if (!history.length) {
+          history = getRouteHistory(routes, index, backBehavior, initialRouteName);
+        }
+        return {
+          ...state,
+          history,
+          routeNames,
+          routes,
+          index
+        };
+      },
+      getStateForRouteFocus(state, key) {
+        var index = state.routes.findIndex(r => r.key === key);
+        if (index === -1 || index === state.index) {
+          return state;
+        }
+        return changeIndex(state, index, backBehavior, initialRouteName);
+      },
+      getStateForAction(state, action, {
+        routeParamList,
+        routeGetIdList
+      }) {
+        switch (action.type) {
+          case 'JUMP_TO':
+          case 'NAVIGATE':
+          case 'NAVIGATE_DEPRECATED':
+            {
+              var index = state.routes.findIndex(route => route.name === action.payload.name);
+              if (index === -1) {
+                return null;
+              }
+              var updatedState = changeIndex({
+                ...state,
+                routes: state.routes.map(route => {
+                  if (route.name !== action.payload.name) {
+                    return route;
+                  }
+                  var getId = routeGetIdList[route.name];
+                  var currentId = getId?.({
+                    params: route.params
+                  });
+                  var nextId = getId?.({
+                    params: action.payload.params
+                  });
+                  var key = currentId === nextId ? route.key : `${route.name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`;
+                  var params;
+                  if ((action.type === 'NAVIGATE' || action.type === 'NAVIGATE_DEPRECATED') && action.payload.merge && currentId === nextId) {
+                    params = action.payload.params !== undefined || routeParamList[route.name] !== undefined ? {
+                      ...routeParamList[route.name],
+                      ...route.params,
+                      ...action.payload.params
+                    } : route.params;
+                  } else {
+                    params = (0, _$$_REQUIRE(_dependencyMap[2]).createParamsFromAction)({
+                      action,
+                      routeParamList
+                    });
+                  }
+                  var path = action.type === 'NAVIGATE' && action.payload.path != null ? action.payload.path : route.path;
+                  return params !== route.params || path !== route.path ? {
+                    ...route,
+                    key,
+                    path,
+                    params
+                  } : route;
+                })
+              }, index, backBehavior, initialRouteName);
+              return {
+                ...updatedState,
+                preloadedRouteKeys: updatedState.preloadedRouteKeys.filter(key => key !== state.routes[updatedState.index].key)
+              };
+            }
+          case 'SET_PARAMS':
+          case 'REPLACE_PARAMS':
+            {
+              var nextState = _$$_REQUIRE(_dependencyMap[0]).BaseRouter.getStateForAction(state, action);
+              if (nextState !== null) {
+                var _index = nextState.index;
+                if (_index != null) {
+                  var focusedRoute = nextState.routes[_index];
+                  var historyItemIndex = state.history.findLastIndex(item => item.key === focusedRoute.key);
+                  var updatedHistory = state.history;
+                  if (historyItemIndex !== -1) {
+                    updatedHistory = [...state.history];
+                    updatedHistory[historyItemIndex] = {
+                      ...updatedHistory[historyItemIndex],
+                      params: focusedRoute.params
+                    };
+                  }
+                  return {
+                    ...nextState,
+                    history: updatedHistory
+                  };
+                }
+              }
+              return nextState;
+            }
+          case 'GO_BACK':
+            {
+              if (state.history.length === 1) {
+                return null;
+              }
+              var previousHistoryItem = state.history[state.history.length - 2];
+              var previousKey = previousHistoryItem?.key;
+              var _index2 = state.routes.findLastIndex(route => route.key === previousKey);
+              if (_index2 === -1) {
+                return null;
+              }
+              var routes = state.routes;
+              if (backBehavior === 'fullHistory' && routes[_index2].params !== previousHistoryItem.params) {
+                routes = [...state.routes];
+                routes[_index2] = {
+                  ...routes[_index2],
+                  params: previousHistoryItem.params
+                };
+              }
+              return {
+                ...state,
+                routes,
+                preloadedRouteKeys: state.preloadedRouteKeys.filter(key => key !== state.routes[_index2].key),
+                history: state.history.slice(0, -1),
+                index: _index2
+              };
+            }
+          case 'PRELOAD':
+            {
+              var routeIndex = state.routes.findIndex(route => route.name === action.payload.name);
+              if (routeIndex === -1) {
+                return null;
+              }
+              var route = state.routes[routeIndex];
+              var getId = routeGetIdList[route.name];
+              var currentId = getId?.({
+                params: route.params
+              });
+              var nextId = getId?.({
+                params: action.payload.params
+              });
+              var key = currentId === nextId ? route.key : `${route.name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`;
+              var params = (0, _$$_REQUIRE(_dependencyMap[2]).createParamsFromAction)({
+                action,
+                routeParamList
+              });
+              var newRoute = params !== route.params ? {
+                ...route,
+                key,
+                params
+              } : route;
+              return {
+                ...state,
+                preloadedRouteKeys: state.preloadedRouteKeys.filter(key => key !== route.key).concat(newRoute.key),
+                routes: state.routes.map((route, index) => index === routeIndex ? newRoute : route),
+                history: key === route.key ? state.history : state.history.filter(record => record.key !== route.key)
+              };
+            }
+          default:
+            return _$$_REQUIRE(_dependencyMap[0]).BaseRouter.getStateForAction(state, action);
+        }
+      },
+      actionCreators: TabActions
+    };
+    return router;
+  }
+},"cdf36facce344b18753d",["4aa609d49dd4d9fd69d8","f9dacdfad56c8f57acc2","f37671f481d3442f7534"]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createParamsFromAction = createParamsFromAction;
+  function createParamsFromAction({
+    action,
+    routeParamList
+  }) {
+    var _action$payload = action.payload,
+      name = _action$payload.name,
+      params = _action$payload.params;
+    return routeParamList[name] !== undefined ? {
+      ...routeParamList[name],
+      ...params
+    } : params;
+  }
+},"f37671f481d3442f7534",[]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.StackActions = undefined;
+  exports.StackRouter = StackRouter;
+  var StackActions = exports.StackActions = {
+    replace(name, params) {
+      return {
+        type: 'REPLACE',
+        payload: {
+          name,
+          params
+        }
+      };
+    },
+    push(name, params) {
+      return {
+        type: 'PUSH',
+        payload: {
+          name,
+          params
+        }
+      };
+    },
+    pop(count = 1) {
+      return {
+        type: 'POP',
+        payload: {
+          count
+        }
+      };
+    },
+    popToTop() {
+      return {
+        type: 'POP_TO_TOP'
+      };
+    },
+    popTo(name, params, options) {
+      if (typeof options === 'boolean') {
+        console.warn(`Passing a boolean as the third argument to 'popTo' is deprecated. Pass '{ merge: true }' instead.`);
+      }
+      return {
+        type: 'POP_TO',
+        payload: {
+          name,
+          params,
+          merge: typeof options === 'boolean' ? options : options?.merge
+        }
+      };
+    }
+  };
+  function StackRouter(options) {
+    var router = {
+      ..._$$_REQUIRE(_dependencyMap[0]).BaseRouter,
+      type: 'stack',
+      getInitialState({
+        routeNames,
+        routeParamList
+      }) {
+        var initialRouteName = options.initialRouteName !== undefined && routeNames.includes(options.initialRouteName) ? options.initialRouteName : routeNames[0];
+        return {
+          stale: false,
+          type: 'stack',
+          key: `stack-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          index: 0,
+          routeNames,
+          preloadedRoutes: [],
+          routes: [{
+            key: `${initialRouteName}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+            name: initialRouteName,
+            params: routeParamList[initialRouteName]
+          }]
+        };
+      },
+      getRehydratedState(partialState, {
+        routeNames,
+        routeParamList
+      }) {
+        var state = partialState;
+        if (state.stale === false) {
+          return state;
+        }
+        var routes = state.routes.filter(route => routeNames.includes(route.name)).map(route => ({
+          ...route,
+          key: route.key || `${route.name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          params: routeParamList[route.name] !== undefined ? {
+            ...routeParamList[route.name],
+            ...route.params
+          } : route.params
+        }));
+        var preloadedRoutes = state.preloadedRoutes?.filter(route => routeNames.includes(route.name)).map(route => ({
+          ...route,
+          key: route.key || `${route.name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          params: routeParamList[route.name] !== undefined ? {
+            ...routeParamList[route.name],
+            ...route.params
+          } : route.params
+        })) ?? [];
+        if (routes.length === 0) {
+          var initialRouteName = options.initialRouteName !== undefined ? options.initialRouteName : routeNames[0];
+          routes.push({
+            key: `${initialRouteName}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+            name: initialRouteName,
+            params: routeParamList[initialRouteName]
+          });
+        }
+        return {
+          stale: false,
+          type: 'stack',
+          key: `stack-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+          index: routes.length - 1,
+          routeNames,
+          routes,
+          preloadedRoutes
+        };
+      },
+      getStateForRouteNamesChange(state, {
+        routeNames,
+        routeParamList,
+        routeKeyChanges
+      }) {
+        var routes = state.routes.filter(route => routeNames.includes(route.name) && !routeKeyChanges.includes(route.name));
+        if (routes.length === 0) {
+          var initialRouteName = options.initialRouteName !== undefined && routeNames.includes(options.initialRouteName) ? options.initialRouteName : routeNames[0];
+          routes.push({
+            key: `${initialRouteName}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+            name: initialRouteName,
+            params: routeParamList[initialRouteName]
+          });
+        }
+        return {
+          ...state,
+          routeNames,
+          routes,
+          index: Math.min(state.index, routes.length - 1)
+        };
+      },
+      getStateForRouteFocus(state, key) {
+        var index = state.routes.findIndex(r => r.key === key);
+        if (index === -1 || index === state.index) {
+          return state;
+        }
+        return {
+          ...state,
+          index,
+          routes: state.routes.slice(0, index + 1)
+        };
+      },
+      getStateForAction(state, action, options) {
+        var routeParamList = options.routeParamList;
+        switch (action.type) {
+          case 'REPLACE':
+            {
+              var currentIndex = action.target === state.key && action.source ? state.routes.findIndex(r => r.key === action.source) : state.index;
+              if (currentIndex === -1) {
+                return null;
+              }
+              if (!state.routeNames.includes(action.payload.name)) {
+                return null;
+              }
+              var getId = options.routeGetIdList[action.payload.name];
+              var id = getId?.({
+                params: action.payload.params
+              });
+
+              // Re-use preloaded route if available
+              var route = state.preloadedRoutes.find(route => route.name === action.payload.name && id === getId?.({
+                params: route.params
+              }));
+              if (!route) {
+                route = (0, _$$_REQUIRE(_dependencyMap[2]).createRouteFromAction)({
+                  action,
+                  routeParamList
+                });
+              }
+              return {
+                ...state,
+                routes: state.routes.map((r, i) => i === currentIndex ? route : r),
+                preloadedRoutes: state.preloadedRoutes.filter(r => r.key !== route.key)
+              };
+            }
+          case 'PUSH':
+          case 'NAVIGATE':
+            {
+              if (!state.routeNames.includes(action.payload.name)) {
+                return null;
+              }
+              var _getId = options.routeGetIdList[action.payload.name];
+              var _id = _getId?.({
+                params: action.payload.params
+              });
+              var _route;
+              if (_id !== undefined) {
+                _route = state.routes.findLast(route => route.name === action.payload.name && _id === _getId?.({
+                  params: route.params
+                }));
+              } else if (action.type === 'NAVIGATE') {
+                var currentRoute = state.routes[state.index];
+
+                // If the route matches the current one, then navigate to it
+                if (action.payload.name === currentRoute.name) {
+                  _route = currentRoute;
+                } else if (action.payload.pop) {
+                  _route = state.routes.findLast(route => route.name === action.payload.name);
+                }
+              }
+              if (!_route) {
+                _route = state.preloadedRoutes.find(route => route.name === action.payload.name && _id === _getId?.({
+                  params: route.params
+                }));
+              }
+              var params;
+              if (action.type === 'NAVIGATE' && action.payload.merge && _route) {
+                params = action.payload.params !== undefined || routeParamList[action.payload.name] !== undefined ? {
+                  ...routeParamList[action.payload.name],
+                  ..._route.params,
+                  ...action.payload.params
+                } : _route.params;
+              } else {
+                params = (0, _$$_REQUIRE(_dependencyMap[3]).createParamsFromAction)({
+                  action,
+                  routeParamList
+                });
+              }
+              var routes;
+              if (_route) {
+                if (action.type === 'NAVIGATE' && action.payload.pop) {
+                  routes = [];
+
+                  // Get all routes until the matching one
+                  for (var r of state.routes) {
+                    if (r.key === _route.key) {
+                      routes.push({
+                        ..._route,
+                        path: action.payload.path !== undefined ? action.payload.path : _route.path,
+                        params
+                      });
+                      break;
+                    }
+                    routes.push(r);
+                  }
+                } else {
+                  routes = state.routes.filter(r => r.key !== _route.key);
+                  routes.push({
+                    ..._route,
+                    path: action.type === 'NAVIGATE' && action.payload.path !== undefined ? action.payload.path : _route.path,
+                    params
+                  });
+                }
+              } else {
+                routes = [...state.routes, {
+                  key: `${action.payload.name}-${(0, _$$_REQUIRE(_dependencyMap[1]).nanoid)()}`,
+                  name: action.payload.name,
+                  path: action.type === 'NAVIGATE' ? action.payload.path : undefined,
+                  params
+                }];
+              }
+              return {
+                ...state,
+                index: routes.length - 1,
+                preloadedRoutes: state.preloadedRoutes.filter(route => routes[routes.length - 1].key !== route.key),
+                routes
+              };
+            }
+          case 'NAVIGATE_DEPRECATED':
+            {
+              if (!state.routeNames.includes(action.payload.name)) {
+                return null;
+              }
+              if (state.preloadedRoutes.find(route => route.name === action.payload.name && _id2 === _getId2?.({
+                params: route.params
+              }))) {
+                return null;
+              }
+
+              // If the route already exists, navigate to that
+              var index = -1;
+              var _getId2 = options.routeGetIdList[action.payload.name];
+              var _id2 = _getId2?.({
+                params: action.payload.params
+              });
+              if (_id2 !== undefined) {
+                index = state.routes.findIndex(route => route.name === action.payload.name && _id2 === _getId2?.({
+                  params: route.params
+                }));
+              } else if (state.routes[state.index].name === action.payload.name) {
+                index = state.index;
+              } else {
+                index = state.routes.findLastIndex(route => route.name === action.payload.name);
+              }
+              if (index === -1) {
+                var _routes = [...state.routes, (0, _$$_REQUIRE(_dependencyMap[2]).createRouteFromAction)({
+                  action,
+                  routeParamList
+                })];
+                return {
+                  ...state,
+                  routes: _routes,
+                  index: _routes.length - 1
+                };
+              }
+              var _route2 = state.routes[index];
+              var _params;
+              if (action.payload.merge) {
+                _params = action.payload.params !== undefined || routeParamList[_route2.name] !== undefined ? {
+                  ...routeParamList[_route2.name],
+                  ..._route2.params,
+                  ...action.payload.params
+                } : _route2.params;
+              } else {
+                _params = (0, _$$_REQUIRE(_dependencyMap[3]).createParamsFromAction)({
+                  action,
+                  routeParamList
+                });
+              }
+              return {
+                ...state,
+                index,
+                routes: [...state.routes.slice(0, index), _params !== _route2.params ? {
+                  ..._route2,
+                  params: _params
+                } : state.routes[index]]
+              };
+            }
+          case 'POP':
+            {
+              var _currentIndex = action.target === state.key && action.source ? state.routes.findIndex(r => r.key === action.source) : state.index;
+              if (_currentIndex > 0) {
+                var count = Math.max(_currentIndex - action.payload.count + 1, 1);
+                var _routes2 = state.routes.slice(0, count).concat(state.routes.slice(_currentIndex + 1));
+                return {
+                  ...state,
+                  index: _routes2.length - 1,
+                  routes: _routes2
+                };
+              }
+              return null;
+            }
+          case 'POP_TO_TOP':
+            return router.getStateForAction(state, {
+              type: 'POP',
+              payload: {
+                count: state.routes.length - 1
+              }
+            }, options);
+          case 'POP_TO':
+            {
+              var _currentIndex2 = action.target === state.key && action.source ? state.routes.findLastIndex(r => r.key === action.source) : state.index;
+              if (_currentIndex2 === -1) {
+                return null;
+              }
+              if (!state.routeNames.includes(action.payload.name)) {
+                return null;
+              }
+
+              // If the route already exists, navigate to it
+              var _index = -1;
+              var _getId3 = options.routeGetIdList[action.payload.name];
+              var _id3 = _getId3?.({
+                params: action.payload.params
+              });
+              if (_id3 !== undefined) {
+                _index = state.routes.findIndex(route => route.name === action.payload.name && _id3 === _getId3?.({
+                  params: route.params
+                }));
+              } else if (state.routes[_currentIndex2].name === action.payload.name) {
+                _index = _currentIndex2;
+              } else {
+                for (var i = _currentIndex2; i >= 0; i--) {
+                  if (state.routes[i].name === action.payload.name) {
+                    _index = i;
+                    break;
+                  }
+                }
+              }
+
+              // If the route doesn't exist, remove the current route and add the new one
+              if (_index === -1) {
+                // Re-use preloaded route if available
+                var _route3 = state.preloadedRoutes.find(route => route.name === action.payload.name && _id3 === _getId3?.({
+                  params: route.params
+                }));
+                if (!_route3) {
+                  _route3 = (0, _$$_REQUIRE(_dependencyMap[2]).createRouteFromAction)({
+                    action,
+                    routeParamList
+                  });
+                }
+                var _routes3 = state.routes.slice(0, _currentIndex2).concat(_route3);
+                return {
+                  ...state,
+                  index: _routes3.length - 1,
+                  routes: _routes3,
+                  preloadedRoutes: state.preloadedRoutes.filter(r => r.key !== _route3.key)
+                };
+              }
+              var _route4 = state.routes[_index];
+              var _params2;
+              if (action.payload.merge) {
+                _params2 = action.payload.params !== undefined || routeParamList[_route4.name] !== undefined ? {
+                  ...routeParamList[_route4.name],
+                  ..._route4.params,
+                  ...action.payload.params
+                } : _route4.params;
+              } else {
+                _params2 = (0, _$$_REQUIRE(_dependencyMap[3]).createParamsFromAction)({
+                  action,
+                  routeParamList
+                });
+              }
+              return {
+                ...state,
+                index: _index,
+                routes: [...state.routes.slice(0, _index), _params2 !== _route4.params ? {
+                  ..._route4,
+                  params: _params2
+                } : state.routes[_index]]
+              };
+            }
+          case 'GO_BACK':
+            if (state.index > 0) {
+              return router.getStateForAction(state, {
+                type: 'POP',
+                payload: {
+                  count: 1
+                },
+                target: action.target,
+                source: action.source
+              }, options);
+            }
+            return null;
+          case 'PRELOAD':
+            {
+              var _getId4 = options.routeGetIdList[action.payload.name];
+              var _id4 = _getId4?.({
+                params: action.payload.params
+              });
+              var _route5;
+              if (_id4 !== undefined) {
+                _route5 = state.routes.find(route => route.name === action.payload.name && _id4 === _getId4?.({
+                  params: route.params
+                }));
+              }
+              if (_route5) {
+                return {
+                  ...state,
+                  routes: state.routes.map(r => {
+                    if (r.key !== _route5?.key) {
+                      return r;
+                    }
+                    return {
+                      ...r,
+                      params: (0, _$$_REQUIRE(_dependencyMap[3]).createParamsFromAction)({
+                        action,
+                        routeParamList
+                      })
+                    };
+                  })
+                };
+              } else {
+                return {
+                  ...state,
+                  preloadedRoutes: state.preloadedRoutes.filter(r => r.name !== action.payload.name || _id4 !== _getId4?.({
+                    params: r.params
+                  })).concat((0, _$$_REQUIRE(_dependencyMap[2]).createRouteFromAction)({
+                    action,
+                    routeParamList
+                  }))
+                };
+              }
+            }
+          default:
+            return _$$_REQUIRE(_dependencyMap[0]).BaseRouter.getStateForAction(state, action);
+        }
+      },
+      actionCreators: StackActions
+    };
+    return router;
+  }
+},"2beefa0726d547efb6db",["4aa609d49dd4d9fd69d8","f9dacdfad56c8f57acc2","c69c3cb84fab85c7ab0e","f37671f481d3442f7534"]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.createRouteFromAction = createRouteFromAction;
+  function createRouteFromAction({
+    action,
+    routeParamList
+  }) {
+    var name = action.payload.name;
+    return {
+      key: `${name}-${(0, _$$_REQUIRE(_dependencyMap[0]).nanoid)()}`,
+      name,
+      params: (0, _$$_REQUIRE(_dependencyMap[1]).createParamsFromAction)({
+        action,
+        routeParamList
+      })
+    };
+  }
+},"c69c3cb84fab85c7ab0e",["f9dacdfad56c8f57acc2","f37671f481d3442f7534"]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.goBack = goBack;
+  exports.navigate = navigate;
+  exports.navigateDeprecated = navigateDeprecated;
+  exports.preload = preload;
+  exports.replaceParams = replaceParams;
+  exports.reset = reset;
+  exports.setParams = setParams;
+  function goBack() {
+    return {
+      type: 'GO_BACK'
+    };
+  }
+  function navigate(...args) {
+    if (typeof args[0] === 'string') {
+      var name = args[0],
+        params = args[1],
+        options = args[2];
+      if (typeof options === 'boolean') {
+        console.warn(`Passing a boolean as the third argument to 'navigate' is deprecated. Pass '{ merge: true }' instead.`);
+      }
+      return {
+        type: 'NAVIGATE',
+        payload: {
+          name,
+          params,
+          merge: typeof options === 'boolean' ? options : options?.merge,
+          pop: options?.pop
+        }
+      };
+    } else {
+      var payload = args[0] || {};
+      if (!('name' in payload)) {
+        throw new Error('You need to specify a name when calling navigate with an object as the argument. See https://reactnavigation.org/docs/navigation-actions#navigate for usage.');
+      }
+      return {
+        type: 'NAVIGATE',
+        payload
+      };
+    }
+  }
+  function navigateDeprecated(...args) {
+    if (typeof args[0] === 'string') {
+      return {
+        type: 'NAVIGATE_DEPRECATED',
+        payload: {
+          name: args[0],
+          params: args[1]
+        }
+      };
+    } else {
+      var payload = args[0] || {};
+      if (!('name' in payload)) {
+        throw new Error('You need to specify a name when calling navigateDeprecated with an object as the argument. See https://reactnavigation.org/docs/navigation-actions#navigatelegacy for usage.');
+      }
+      return {
+        type: 'NAVIGATE_DEPRECATED',
+        payload
+      };
+    }
+  }
+  function reset(state) {
+    return {
+      type: 'RESET',
+      payload: state
+    };
+  }
+  function setParams(params) {
+    return {
+      type: 'SET_PARAMS',
+      payload: {
+        params
+      }
+    };
+  }
+  function replaceParams(params) {
+    return {
+      type: 'REPLACE_PARAMS',
+      payload: {
+        params
+      }
+    };
+  }
+  function preload(name, params) {
+    return {
+      type: 'PRELOAD',
+      payload: {
+        name,
+        params
+      }
+    };
+  }
+},"6664264a195fd5e23d1d",[]);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+},"42552d18e7ae0181bd39",[]);