{"version":3,"file":"static/js/8410.c6bd0efd.chunk.js","mappings":"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","sources":["../node_modules/babel-cms/src/I18nProvider/types/i18n.ts","../node_modules/wabelane/src/ui-components/common/ToastNotification/types.ts","../node_modules/wabelane/src/ui-components/table/components/table-dropdown/messages.ts","../node_modules/wabelane/src/ui-components/table/components/table-dropdown/utils.ts","../node_modules/@remix-run/router/history.ts","../node_modules/@remix-run/router/utils.ts","../node_modules/@remix-run/router/router.ts","../node_modules/react-dom/client.js","../node_modules/react-router/lib/context.ts","../node_modules/react-router/lib/hooks.tsx","../node_modules/react-router/lib/components.tsx","../node_modules/react-router/index.ts","../node_modules/react/cjs/react-jsx-runtime.production.min.js","../node_modules/react/jsx-runtime.js","../node_modules/redux-devtools-extension/logOnly.js","../node_modules/redux-devtools-extension/logOnlyInProduction.js","../node_modules/redux-devtools-extension/utils/assign.js","../../packages/utilities/src/index.ts","../node_modules/@tanstack/query-core/src/mutation.ts","../node_modules/@tanstack/query-core/src/utils.ts","../node_modules/lodash-es/noop.js"],"sourcesContent":["import { Asset } from 'contentful'\n\nexport interface I18nMessages {\n [key: string]: string\n}\n\nexport interface CMSItem {\n id: string\n text: string\n description: string\n partner: string\n}\n\nexport interface CMSPayload {\n messages: CMSItem[]\n assets: Array\n}\n\nexport interface I18nPayload {\n messages: I18nMessages\n assets: any[]\n}\n\nexport type AppName =\n | 'dashboard'\n | 'login'\n | 'registration'\n | 'mobile'\n | 'email'\n | 'deposit'\n\nexport type Locale = string\n\n// codes taken from https://github.com/matteocng/react-flag-icon-css/blob/master/src/static/enums.js#L24\nexport type FlagCode = string\n\nexport interface AvailableLanguage {\n locale: Locale\n label: string\n name: string\n flagCode: FlagCode\n}\n\nexport enum PartnerName {\n Moneycorp = 'moneycorp',\n MoneycorpUs = 'moneycorpus',\n DerivativeLogic = 'derivativelogic',\n Shipmoney = 'shipmoney',\n HardingBell = 'hardingbell',\n KnightFrank = 'knightfrank'\n}\n","export interface ToastNotificationProps {\n id?: string\n className?: string\n withTitle?: boolean\n withShadow?: boolean\n withErrorIcon?: boolean\n withCloseIcon?: boolean\n onClose?: any\n titleMessage?: string\n notificationType: NotificationType\n titleTextColor?: string\n backgroundColor?: string\n padding?: string\n crossIconSize?: string\n onMouseEnter?: any\n onMouseLeave?: any\n textAlign?: string\n}\nexport interface NotificationWrapperProps {\n backgroundColor?: string\n padding: string\n shadow?: boolean\n textAlign?: string\n}\n\nexport enum NotificationType {\n Warning = 'Warning',\n Error = 'Error',\n Success = 'Success',\n Info = 'Info',\n Default = 'Default'\n}\n","import { MessageDescriptor } from 'react-intl'\n\nexport const OneOrMoreItemsSelected: MessageDescriptor = {\n id: 'filters.OneOrMoreItemsSelected',\n defaultMessage: 'Selected',\n description:\n 'The text shown in the filter component when one or more but not all are selected'\n}\n\nexport const NoItemsSelected: MessageDescriptor = {\n id: 'filters.NoItemsSelected',\n defaultMessage: '-Select-',\n description:\n 'The text shown in the filter component when no items are selected'\n}\n\nexport const AllItemsSelected: MessageDescriptor = {\n id: 'filters.AllItemsSelected',\n defaultMessage: 'All',\n description:\n 'The text shown in the filter component when ALL items are selected'\n}\n\nexport const SelectAll: MessageDescriptor = {\n id: 'filters.SelectAll',\n defaultMessage: 'Select all',\n description:\n 'The text shown in the filter which controls the select/deselect all items'\n}\n\nexport const ApplyFilters: MessageDescriptor = {\n id: 'filters.button.ApplyFilters',\n defaultMessage: 'Apply filters',\n description: 'The text shown in the button at the bottom of the filter list'\n}\n\nexport const NoFilters: MessageDescriptor = {\n id: 'filters.button.NoFilters',\n defaultMessage: 'No filters found',\n description:\n 'The text shown in filter list when no filters are found by the search criteria'\n}\n","import { IntlShape } from 'react-intl'\n\n// TYPES & CONSTANTS\nimport * as messages from './messages'\nimport { FilterCheckbox } from './types'\nimport { FiltersWithSelectedStatus } from '../../types'\n\nexport const setCheckboxesState = (\n checkboxes: FilterCheckbox[],\n bulkCheckboxState?: boolean\n): FilterCheckbox[] =>\n checkboxes.map(checkbox => {\n const { isSelected } = checkbox\n\n const isCheckboxWithState = bulkCheckboxState ?? isSelected\n\n return {\n ...checkbox,\n isSelected: isCheckboxWithState\n }\n })\n\nexport const renderInfoText = (\n intl: IntlShape,\n isOneOrMoreSelected: boolean,\n areAllSelected: boolean,\n infoText: string\n) => {\n if (infoText) {\n return infoText\n }\n\n if (areAllSelected) {\n return intl.formatMessage(messages.AllItemsSelected)\n }\n\n if (isOneOrMoreSelected) {\n return intl.formatMessage(messages.OneOrMoreItemsSelected)\n }\n\n return intl.formatMessage(messages.NoItemsSelected)\n}\n\nexport const getNumberOfSelectedFilters = (\n filters: FiltersWithSelectedStatus[]\n) => {\n let result = 0\n\n filters.forEach(filter => {\n if (!filter.every(({ isSelected }) => isSelected)) {\n result += 1\n }\n })\n\n return result\n}\n","////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n /**\n * A POP indicates a change to an arbitrary index in the history stack, such\n * as a back or forward navigation. It does not describe the direction of the\n * navigation, only that the current index changed.\n *\n * Note: This is the default action for newly created history objects.\n */\n Pop = \"POP\",\n\n /**\n * A PUSH indicates a new entry being added to the history stack, such as when\n * a link is clicked and a new page loads. When this happens, all subsequent\n * entries in the stack are lost.\n */\n Push = \"PUSH\",\n\n /**\n * A REPLACE indicates the entry at the current index in the history stack\n * being replaced by a new one.\n */\n Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n /**\n * A URL pathname, beginning with a /.\n */\n pathname: string;\n\n /**\n * A URL search string, beginning with a ?.\n */\n search: string;\n\n /**\n * A URL fragment identifier, beginning with a #.\n */\n hash: string;\n}\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location extends Path {\n /**\n * A value of arbitrary data associated with this location.\n */\n state: any;\n\n /**\n * A unique string associated with this location. May be used to safely store\n * and retrieve data in some other storage API, like `localStorage`.\n *\n * Note: This value is always \"default\" on the initial location.\n */\n key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n /**\n * The action that triggered the change.\n */\n action: Action;\n\n /**\n * The new location.\n */\n location: Location;\n\n /**\n * The delta between this location and the former location in the history stack\n */\n delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. May be either a URL or the pieces of a\n * URL path.\n */\nexport type To = string | Partial;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n /**\n * The last action that modified the current location. This will always be\n * Action.Pop when a history instance is first created. This value is mutable.\n */\n readonly action: Action;\n\n /**\n * The current location. This value is mutable.\n */\n readonly location: Location;\n\n /**\n * Returns a valid href for the given `to` value that may be used as\n * the value of an attribute.\n *\n * @param to - The destination URL\n */\n createHref(to: To): string;\n\n /**\n * Returns a URL for the given `to` value\n *\n * @param to - The destination URL\n */\n createURL(to: To): URL;\n\n /**\n * Encode a location the same way window.history would do (no-op for memory\n * history) so we ensure our PUSH/REPLACE navigations for data routers\n * behave the same as POP\n *\n * @param to Unencoded path\n */\n encodeLocation(to: To): Path;\n\n /**\n * Pushes a new location onto the history stack, increasing its length by one.\n * If there were any entries in the stack after the current one, they are\n * lost.\n *\n * @param to - The new URL\n * @param state - Data to associate with the new location\n */\n push(to: To, state?: any): void;\n\n /**\n * Replaces the current location in the history stack with a new one. The\n * location that was replaced will no longer be available.\n *\n * @param to - The new URL\n * @param state - Data to associate with the new location\n */\n replace(to: To, state?: any): void;\n\n /**\n * Navigates `n` entries backward/forward in the history stack relative to the\n * current index. For example, a \"back\" navigation would use go(-1).\n *\n * @param delta - The delta in the stack index\n */\n go(delta: number): void;\n\n /**\n * Sets up a listener that will be called whenever the current location\n * changes.\n *\n * @param listener - A function that will be called when the location changes\n * @returns unlisten - A function that may be used to stop listening\n */\n listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n usr: any;\n key?: string;\n idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial;\n\nexport type MemoryHistoryOptions = {\n initialEntries?: InitialEntry[];\n initialIndex?: number;\n v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n /**\n * The current index in the history stack.\n */\n readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n options: MemoryHistoryOptions = {}\n): MemoryHistory {\n let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n let entries: Location[]; // Declare so we can access from createMemoryLocation\n entries = initialEntries.map((entry, index) =>\n createMemoryLocation(\n entry,\n typeof entry === \"string\" ? null : entry.state,\n index === 0 ? \"default\" : undefined\n )\n );\n let index = clampIndex(\n initialIndex == null ? entries.length - 1 : initialIndex\n );\n let action = Action.Pop;\n let listener: Listener | null = null;\n\n function clampIndex(n: number): number {\n return Math.min(Math.max(n, 0), entries.length - 1);\n }\n function getCurrentLocation(): Location {\n return entries[index];\n }\n function createMemoryLocation(\n to: To,\n state: any = null,\n key?: string\n ): Location {\n let location = createLocation(\n entries ? getCurrentLocation().pathname : \"/\",\n to,\n state,\n key\n );\n warning(\n location.pathname.charAt(0) === \"/\",\n `relative pathnames are not supported in memory history: ${JSON.stringify(\n to\n )}`\n );\n return location;\n }\n\n function createHref(to: To) {\n return typeof to === \"string\" ? to : createPath(to);\n }\n\n let history: MemoryHistory = {\n get index() {\n return index;\n },\n get action() {\n return action;\n },\n get location() {\n return getCurrentLocation();\n },\n createHref,\n createURL(to) {\n return new URL(createHref(to), \"http://localhost\");\n },\n encodeLocation(to: To) {\n let path = typeof to === \"string\" ? parsePath(to) : to;\n return {\n pathname: path.pathname || \"\",\n search: path.search || \"\",\n hash: path.hash || \"\",\n };\n },\n push(to, state) {\n action = Action.Push;\n let nextLocation = createMemoryLocation(to, state);\n index += 1;\n entries.splice(index, entries.length, nextLocation);\n if (v5Compat && listener) {\n listener({ action, location: nextLocation, delta: 1 });\n }\n },\n replace(to, state) {\n action = Action.Replace;\n let nextLocation = createMemoryLocation(to, state);\n entries[index] = nextLocation;\n if (v5Compat && listener) {\n listener({ action, location: nextLocation, delta: 0 });\n }\n },\n go(delta) {\n action = Action.Pop;\n let nextIndex = clampIndex(index + delta);\n let nextLocation = entries[nextIndex];\n index = nextIndex;\n if (listener) {\n listener({ action, location: nextLocation, delta });\n }\n },\n listen(fn: Listener) {\n listener = fn;\n return () => {\n listener = null;\n };\n },\n };\n\n return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n options: BrowserHistoryOptions = {}\n): BrowserHistory {\n function createBrowserLocation(\n window: Window,\n globalHistory: Window[\"history\"]\n ) {\n let { pathname, search, hash } = window.location;\n return createLocation(\n \"\",\n { pathname, search, hash },\n // state defaults to `null` because `window.history.state` does\n (globalHistory.state && globalHistory.state.usr) || null,\n (globalHistory.state && globalHistory.state.key) || \"default\"\n );\n }\n\n function createBrowserHref(window: Window, to: To) {\n return typeof to === \"string\" ? to : createPath(to);\n }\n\n return getUrlBasedHistory(\n createBrowserLocation,\n createBrowserHref,\n null,\n options\n );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n options: HashHistoryOptions = {}\n): HashHistory {\n function createHashLocation(\n window: Window,\n globalHistory: Window[\"history\"]\n ) {\n let {\n pathname = \"/\",\n search = \"\",\n hash = \"\",\n } = parsePath(window.location.hash.substr(1));\n return createLocation(\n \"\",\n { pathname, search, hash },\n // state defaults to `null` because `window.history.state` does\n (globalHistory.state && globalHistory.state.usr) || null,\n (globalHistory.state && globalHistory.state.key) || \"default\"\n );\n }\n\n function createHashHref(window: Window, to: To) {\n let base = window.document.querySelector(\"base\");\n let href = \"\";\n\n if (base && base.getAttribute(\"href\")) {\n let url = window.location.href;\n let hashIndex = url.indexOf(\"#\");\n href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n }\n\n return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n }\n\n function validateHashLocation(location: Location, to: To) {\n warning(\n location.pathname.charAt(0) === \"/\",\n `relative pathnames are not supported in hash history.push(${JSON.stringify(\n to\n )})`\n );\n }\n\n return getUrlBasedHistory(\n createHashLocation,\n createHashHref,\n validateHashLocation,\n options\n );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant(\n value: T | null | undefined,\n message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n if (value === false || value === null || typeof value === \"undefined\") {\n throw new Error(message);\n }\n}\n\nexport function warning(cond: any, message: string) {\n if (!cond) {\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\") console.warn(message);\n\n try {\n // Welcome to debugging history!\n //\n // This error is thrown as a convenience so you can more easily\n // find the source for a warning that appears in the console by\n // enabling \"pause on exceptions\" in your JavaScript debugger.\n throw new Error(message);\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n}\n\nfunction createKey() {\n return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n return {\n usr: location.state,\n key: location.key,\n idx: index,\n };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n current: string | Location,\n to: To,\n state: any = null,\n key?: string\n): Readonly {\n let location: Readonly = {\n pathname: typeof current === \"string\" ? current : current.pathname,\n search: \"\",\n hash: \"\",\n ...(typeof to === \"string\" ? parsePath(to) : to),\n state,\n // TODO: This could be cleaned up. push/replace should probably just take\n // full Locations now and avoid the need to run through this flow at all\n // But that's a pretty big refactor to the current test suite so going to\n // keep as is for the time being and just let any incoming keys take precedence\n key: (to && (to as Location).key) || key || createKey(),\n };\n return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n pathname = \"/\",\n search = \"\",\n hash = \"\",\n}: Partial) {\n if (search && search !== \"?\")\n pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n if (hash && hash !== \"#\")\n pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial {\n let parsedPath: Partial = {};\n\n if (path) {\n let hashIndex = path.indexOf(\"#\");\n if (hashIndex >= 0) {\n parsedPath.hash = path.substr(hashIndex);\n path = path.substr(0, hashIndex);\n }\n\n let searchIndex = path.indexOf(\"?\");\n if (searchIndex >= 0) {\n parsedPath.search = path.substr(searchIndex);\n path = path.substr(0, searchIndex);\n }\n\n if (path) {\n parsedPath.pathname = path;\n }\n }\n\n return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n window?: Window;\n v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n createHref: (window: Window, to: To) => string,\n validateLocation: ((location: Location, to: To) => void) | null,\n options: UrlHistoryOptions = {}\n): UrlHistory {\n let { window = document.defaultView!, v5Compat = false } = options;\n let globalHistory = window.history;\n let action = Action.Pop;\n let listener: Listener | null = null;\n\n let index = getIndex()!;\n // Index should only be null when we initialize. If not, it's because the\n // user called history.pushState or history.replaceState directly, in which\n // case we should log a warning as it will result in bugs.\n if (index == null) {\n index = 0;\n globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n }\n\n function getIndex(): number {\n let state = globalHistory.state || { idx: null };\n return state.idx;\n }\n\n function handlePop() {\n action = Action.Pop;\n let nextIndex = getIndex();\n let delta = nextIndex == null ? null : nextIndex - index;\n index = nextIndex;\n if (listener) {\n listener({ action, location: history.location, delta });\n }\n }\n\n function push(to: To, state?: any) {\n action = Action.Push;\n let location = createLocation(history.location, to, state);\n if (validateLocation) validateLocation(location, to);\n\n index = getIndex() + 1;\n let historyState = getHistoryState(location, index);\n let url = history.createHref(location);\n\n // try...catch because iOS limits us to 100 pushState calls :/\n try {\n globalHistory.pushState(historyState, \"\", url);\n } catch (error) {\n // If the exception is because `state` can't be serialized, let that throw\n // outwards just like a replace call would so the dev knows the cause\n // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n if (error instanceof DOMException && error.name === \"DataCloneError\") {\n throw error;\n }\n // They are going to lose state here, but there is no real\n // way to warn them about it since the page will refresh...\n window.location.assign(url);\n }\n\n if (v5Compat && listener) {\n listener({ action, location: history.location, delta: 1 });\n }\n }\n\n function replace(to: To, state?: any) {\n action = Action.Replace;\n let location = createLocation(history.location, to, state);\n if (validateLocation) validateLocation(location, to);\n\n index = getIndex();\n let historyState = getHistoryState(location, index);\n let url = history.createHref(location);\n globalHistory.replaceState(historyState, \"\", url);\n\n if (v5Compat && listener) {\n listener({ action, location: history.location, delta: 0 });\n }\n }\n\n function createURL(to: To): URL {\n // window.location.origin is \"null\" (the literal string value) in Firefox\n // under certain conditions, notably when serving from a local HTML file\n // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n let base =\n window.location.origin !== \"null\"\n ? window.location.origin\n : window.location.href;\n\n let href = typeof to === \"string\" ? to : createPath(to);\n invariant(\n base,\n `No window.location.(origin|href) available to create URL for href: ${href}`\n );\n return new URL(href, base);\n }\n\n let history: History = {\n get action() {\n return action;\n },\n get location() {\n return getLocation(window, globalHistory);\n },\n listen(fn: Listener) {\n if (listener) {\n throw new Error(\"A history only accepts one active listener\");\n }\n window.addEventListener(PopStateEventType, handlePop);\n listener = fn;\n\n return () => {\n window.removeEventListener(PopStateEventType, handlePop);\n listener = null;\n };\n },\n createHref(to) {\n return createHref(window, to);\n },\n createURL,\n encodeLocation(to) {\n // Encode a Location the same way window.location would\n let url = createURL(to);\n return {\n pathname: url.pathname,\n search: url.search,\n hash: url.hash,\n };\n },\n push,\n replace,\n go(n) {\n return globalHistory.go(n);\n },\n };\n\n return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { warning, invariant, parsePath } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n [routeId: string]: any;\n}\n\nexport enum ResultType {\n data = \"data\",\n deferred = \"deferred\",\n redirect = \"redirect\",\n error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n type: ResultType.data;\n data: any;\n statusCode?: number;\n headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n type: ResultType.deferred;\n deferredData: DeferredData;\n statusCode?: number;\n headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n type: ResultType.redirect;\n status: number;\n location: string;\n revalidate: boolean;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n type: ResultType.error;\n error: any;\n headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n | SuccessResult\n | DeferredResult\n | RedirectResult\n | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase;\n\n/**\n * Users can specify either lowercase or uppercase form methods on
,\n * useSubmit(), , etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState. This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude;\n\nexport type FormEncType =\n | \"application/x-www-form-urlencoded\"\n | \"multipart/form-data\"\n | \"application/json\"\n | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n | {\n formMethod: FormMethod | V7_FormMethod;\n formAction: string;\n formEncType: FormEncType;\n formData: FormData;\n json: undefined;\n text: undefined;\n }\n | {\n formMethod: FormMethod | V7_FormMethod;\n formAction: string;\n formEncType: FormEncType;\n formData: undefined;\n json: JsonValue;\n text: undefined;\n }\n | {\n formMethod: FormMethod | V7_FormMethod;\n formAction: string;\n formEncType: FormEncType;\n formData: undefined;\n json: undefined;\n text: string;\n };\n\n/**\n * @private\n * Arguments passed to route loader/action functions. Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs {\n request: Request;\n params: Params;\n context?: any;\n}\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs extends DataFunctionArgs {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs extends DataFunctionArgs {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return). Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable | null;\n\n/**\n * Route loader function signature\n */\nexport interface LoaderFunction {\n (args: LoaderFunctionArgs): Promise | DataFunctionValue;\n}\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction {\n (args: ActionFunctionArgs): Promise | DataFunctionValue;\n}\n\n/**\n * Route shouldRevalidate function signature. This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments. It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n (args: {\n currentUrl: URL;\n currentParams: AgnosticDataRouteMatch[\"params\"];\n nextUrl: URL;\n nextParams: AgnosticDataRouteMatch[\"params\"];\n formMethod?: Submission[\"formMethod\"];\n formAction?: Submission[\"formAction\"];\n formEncType?: Submission[\"formEncType\"];\n text?: Submission[\"text\"];\n formData?: Submission[\"formData\"];\n json?: Submission[\"json\"];\n actionResult?: DataResult;\n defaultShouldRevalidate: boolean;\n }): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n (route: AgnosticRouteObject): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n (route: AgnosticRouteObject): {\n hasErrorBoundary: boolean;\n } & Record;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n | \"lazy\"\n | \"caseSensitive\"\n | \"path\"\n | \"id\"\n | \"index\"\n | \"children\";\n\nexport const immutableRouteKeys = new Set([\n \"lazy\",\n \"caseSensitive\",\n \"path\",\n \"id\",\n \"index\",\n \"children\",\n]);\n\ntype RequireOne = Exclude<\n {\n [K in keyof T]: K extends Key ? Omit & Required> : never;\n }[keyof T],\n undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction {\n (): Promise>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n caseSensitive?: boolean;\n path?: string;\n id?: string;\n loader?: LoaderFunction;\n action?: ActionFunction;\n hasErrorBoundary?: boolean;\n shouldRevalidate?: ShouldRevalidateFunction;\n handle?: any;\n lazy?: LazyRouteFunction;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n children?: undefined;\n index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n children?: AgnosticRouteObject[];\n index?: false;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport type AgnosticRouteObject =\n | AgnosticIndexRouteObject\n | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n children?: AgnosticDataRouteObject[];\n id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n | AgnosticDataIndexRouteObject\n | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam =\n // split path into individual path segments\n Path extends `${infer L}/${infer R}`\n ? _PathParam | _PathParam\n : // find params after `:`\n Path extends `:${infer Param}`\n ? Param extends `${infer Optional}?`\n ? Optional\n : Param\n : // otherwise, there aren't any params present\n never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\ntype PathParam =\n // check if path is just a wildcard\n Path extends \"*\" | \"/*\"\n ? \"*\"\n : // look for wildcard at the end of the path\n Path extends `${infer Rest}/*`\n ? \"*\" | _PathParam\n : // look for params in the absence of wildcards\n _PathParam;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey =\n // if could not find path params, fallback to `string`\n [PathParam] extends [never] ? string : PathParam;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params = {\n readonly [key in Key]: string | undefined;\n};\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n ParamKey extends string = string,\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The route object that was used to match.\n */\n route: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n extends AgnosticRouteMatch {}\n\nfunction isIndexRoute(\n route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n routes: AgnosticRouteObject[],\n mapRouteProperties: MapRoutePropertiesFunction,\n parentPath: number[] = [],\n manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n return routes.map((route, index) => {\n let treePath = [...parentPath, index];\n let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n invariant(\n route.index !== true || !route.children,\n `Cannot specify children on an index route`\n );\n invariant(\n !manifest[id],\n `Found a route id collision on id \"${id}\". Route ` +\n \"id's must be globally unique within Data Router usages\"\n );\n\n if (isIndexRoute(route)) {\n let indexRoute: AgnosticDataIndexRouteObject = {\n ...route,\n ...mapRouteProperties(route),\n id,\n };\n manifest[id] = indexRoute;\n return indexRoute;\n } else {\n let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n ...route,\n ...mapRouteProperties(route),\n id,\n children: undefined,\n };\n manifest[id] = pathOrLayoutRoute;\n\n if (route.children) {\n pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n route.children,\n mapRouteProperties,\n treePath,\n manifest\n );\n }\n\n return pathOrLayoutRoute;\n }\n });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nexport function matchRoutes<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n routes: RouteObjectType[],\n locationArg: Partial | string,\n basename = \"/\"\n): AgnosticRouteMatch[] | null {\n let location =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n let pathname = stripBasename(location.pathname || \"/\", basename);\n\n if (pathname == null) {\n return null;\n }\n\n let branches = flattenRoutes(routes);\n rankRouteBranches(branches);\n\n let matches = null;\n for (let i = 0; matches == null && i < branches.length; ++i) {\n matches = matchRouteBranch(\n branches[i],\n // Incoming pathnames are generally encoded from either window.location\n // or from router.navigate, but we want to match against the unencoded\n // paths in the route definitions. Memory router locations won't be\n // encoded here but there also shouldn't be anything to decode so this\n // should be a safe operation. This avoids needing matchRoutes to be\n // history-aware.\n safelyDecodeURI(pathname)\n );\n }\n\n return matches;\n}\n\ninterface RouteMeta<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n relativePath: string;\n caseSensitive: boolean;\n childrenIndex: number;\n route: RouteObjectType;\n}\n\ninterface RouteBranch<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n path: string;\n score: number;\n routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes<\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n routes: RouteObjectType[],\n branches: RouteBranch[] = [],\n parentsMeta: RouteMeta[] = [],\n parentPath = \"\"\n): RouteBranch[] {\n let flattenRoute = (\n route: RouteObjectType,\n index: number,\n relativePath?: string\n ) => {\n let meta: RouteMeta = {\n relativePath:\n relativePath === undefined ? route.path || \"\" : relativePath,\n caseSensitive: route.caseSensitive === true,\n childrenIndex: index,\n route,\n };\n\n if (meta.relativePath.startsWith(\"/\")) {\n invariant(\n meta.relativePath.startsWith(parentPath),\n `Absolute route path \"${meta.relativePath}\" nested under path ` +\n `\"${parentPath}\" is not valid. An absolute child route path ` +\n `must start with the combined path of all its parent routes.`\n );\n\n meta.relativePath = meta.relativePath.slice(parentPath.length);\n }\n\n let path = joinPaths([parentPath, meta.relativePath]);\n let routesMeta = parentsMeta.concat(meta);\n\n // Add the children before adding this route to the array so we traverse the\n // route tree depth-first and child routes appear before their parents in\n // the \"flattened\" version.\n if (route.children && route.children.length > 0) {\n invariant(\n // Our types know better, but runtime JS may not!\n // @ts-expect-error\n route.index !== true,\n `Index routes must not have child routes. Please remove ` +\n `all child routes from route path \"${path}\".`\n );\n\n flattenRoutes(route.children, branches, routesMeta, path);\n }\n\n // Routes without a path shouldn't ever match by themselves unless they are\n // index routes, so don't add them to the list of possible branches.\n if (route.path == null && !route.index) {\n return;\n }\n\n branches.push({\n path,\n score: computeScore(path, route.index),\n routesMeta,\n });\n };\n routes.forEach((route, index) => {\n // coarse-grain check for optional params\n if (route.path === \"\" || !route.path?.includes(\"?\")) {\n flattenRoute(route, index);\n } else {\n for (let exploded of explodeOptionalSegments(route.path)) {\n flattenRoute(route, index, exploded);\n }\n }\n });\n\n return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n let segments = path.split(\"/\");\n if (segments.length === 0) return [];\n\n let [first, ...rest] = segments;\n\n // Optional path segments are denoted by a trailing `?`\n let isOptional = first.endsWith(\"?\");\n // Compute the corresponding required segment: `foo?` -> `foo`\n let required = first.replace(/\\?$/, \"\");\n\n if (rest.length === 0) {\n // Intepret empty string as omitting an optional segment\n // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n return isOptional ? [required, \"\"] : [required];\n }\n\n let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n let result: string[] = [];\n\n // All child paths with the prefix. Do this for all children before the\n // optional version for all children so we get consistent ordering where the\n // parent optional aspect is preferred as required. Otherwise, we can get\n // child sections interspersed where deeper optional segments are higher than\n // parent optional segments, where for example, /:two would explodes _earlier_\n // then /:one. By always including the parent as required _for all children_\n // first, we avoid this issue\n result.push(\n ...restExploded.map((subpath) =>\n subpath === \"\" ? required : [required, subpath].join(\"/\")\n )\n );\n\n // Then if this is an optional value, add all child versions without\n if (isOptional) {\n result.push(...restExploded);\n }\n\n // for absolute paths, ensure `/` instead of empty segment\n return result.map((exploded) =>\n path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n );\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n branches.sort((a, b) =>\n a.score !== b.score\n ? b.score - a.score // Higher score first\n : compareIndexes(\n a.routesMeta.map((meta) => meta.childrenIndex),\n b.routesMeta.map((meta) => meta.childrenIndex)\n )\n );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n let segments = path.split(\"/\");\n let initialScore = segments.length;\n if (segments.some(isSplat)) {\n initialScore += splatPenalty;\n }\n\n if (index) {\n initialScore += indexRouteValue;\n }\n\n return segments\n .filter((s) => !isSplat(s))\n .reduce(\n (score, segment) =>\n score +\n (paramRe.test(segment)\n ? dynamicSegmentValue\n : segment === \"\"\n ? emptySegmentValue\n : staticSegmentValue),\n initialScore\n );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n let siblings =\n a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n return siblings\n ? // If two routes are siblings, we should try to match the earlier sibling\n // first. This allows people to have fine-grained control over the matching\n // behavior by simply putting routes with identical paths in the order they\n // want them tried.\n a[a.length - 1] - b[b.length - 1]\n : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n // so they sort equally.\n 0;\n}\n\nfunction matchRouteBranch<\n ParamKey extends string = string,\n RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n branch: RouteBranch,\n pathname: string\n): AgnosticRouteMatch[] | null {\n let { routesMeta } = branch;\n\n let matchedParams = {};\n let matchedPathname = \"/\";\n let matches: AgnosticRouteMatch[] = [];\n for (let i = 0; i < routesMeta.length; ++i) {\n let meta = routesMeta[i];\n let end = i === routesMeta.length - 1;\n let remainingPathname =\n matchedPathname === \"/\"\n ? pathname\n : pathname.slice(matchedPathname.length) || \"/\";\n let match = matchPath(\n { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n remainingPathname\n );\n\n if (!match) return null;\n\n Object.assign(matchedParams, match.params);\n\n let route = meta.route;\n\n matches.push({\n // TODO: Can this as be avoided?\n params: matchedParams as Params,\n pathname: joinPaths([matchedPathname, match.pathname]),\n pathnameBase: normalizePathname(\n joinPaths([matchedPathname, match.pathnameBase])\n ),\n route,\n });\n\n if (match.pathnameBase !== \"/\") {\n matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n }\n }\n\n return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nexport function generatePath(\n originalPath: Path,\n params: {\n [key in PathParam]: string | null;\n } = {} as any\n): string {\n let path: string = originalPath;\n if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n warning(\n false,\n `Route path \"${path}\" will be treated as if it were ` +\n `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n );\n path = path.replace(/\\*$/, \"/*\") as Path;\n }\n\n // ensure `/` is added at the beginning if the path is absolute\n const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n const stringify = (p: any) =>\n p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n const segments = path\n .split(/\\/+/)\n .map((segment, index, array) => {\n const isLastSegment = index === array.length - 1;\n\n // only apply the splat if it's the last segment\n if (isLastSegment && segment === \"*\") {\n const star = \"*\" as PathParam;\n // Apply the splat\n return stringify(params[star]);\n }\n\n const keyMatch = segment.match(/^:(\\w+)(\\??)$/);\n if (keyMatch) {\n const [, key, optional] = keyMatch;\n let param = params[key as PathParam];\n invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n return stringify(param);\n }\n\n // Remove any optional markers from optional static segments\n return segment.replace(/\\?$/g, \"\");\n })\n // Remove empty segments\n .filter((segment) => !!segment);\n\n return prefix + segments.join(\"/\");\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern {\n /**\n * A string to match against a URL pathname. May contain `:id`-style segments\n * to indicate placeholders for dynamic parameters. May also end with `/*` to\n * indicate matching the rest of the URL pathname.\n */\n path: Path;\n /**\n * Should be `true` if the static portions of the `path` should be matched in\n * the same case.\n */\n caseSensitive?: boolean;\n /**\n * Should be `true` if this pattern should match the entire URL pathname.\n */\n end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The pattern that was used to match.\n */\n pattern: PathPattern;\n}\n\ntype Mutable = {\n -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nexport function matchPath<\n ParamKey extends ParamParseKey,\n Path extends string\n>(\n pattern: PathPattern | Path,\n pathname: string\n): PathMatch | null {\n if (typeof pattern === \"string\") {\n pattern = { path: pattern, caseSensitive: false, end: true };\n }\n\n let [matcher, paramNames] = compilePath(\n pattern.path,\n pattern.caseSensitive,\n pattern.end\n );\n\n let match = pathname.match(matcher);\n if (!match) return null;\n\n let matchedPathname = match[0];\n let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n let captureGroups = match.slice(1);\n let params: Params = paramNames.reduce>(\n (memo, paramName, index) => {\n // We need to compute the pathnameBase here using the raw splat value\n // instead of using params[\"*\"] later because it will be decoded then\n if (paramName === \"*\") {\n let splatValue = captureGroups[index] || \"\";\n pathnameBase = matchedPathname\n .slice(0, matchedPathname.length - splatValue.length)\n .replace(/(.)\\/+$/, \"$1\");\n }\n\n memo[paramName] = safelyDecodeURIComponent(\n captureGroups[index] || \"\",\n paramName\n );\n return memo;\n },\n {}\n );\n\n return {\n params,\n pathname: matchedPathname,\n pathnameBase,\n pattern,\n };\n}\n\nfunction compilePath(\n path: string,\n caseSensitive = false,\n end = true\n): [RegExp, string[]] {\n warning(\n path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n `Route path \"${path}\" will be treated as if it were ` +\n `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n );\n\n let paramNames: string[] = [];\n let regexpSource =\n \"^\" +\n path\n .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n .replace(/\\/:(\\w+)/g, (_: string, paramName: string) => {\n paramNames.push(paramName);\n return \"/([^\\\\/]+)\";\n });\n\n if (path.endsWith(\"*\")) {\n paramNames.push(\"*\");\n regexpSource +=\n path === \"*\" || path === \"/*\"\n ? \"(.*)$\" // Already matched the initial /, just match the rest\n : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n } else if (end) {\n // When matching to the end, ignore trailing slashes\n regexpSource += \"\\\\/*$\";\n } else if (path !== \"\" && path !== \"/\") {\n // If our path is non-empty and contains anything beyond an initial slash,\n // then we have _some_ form of path in our regex so we should expect to\n // match only if we find the end of this path segment. Look for an optional\n // non-captured trailing slash (to match a portion of the URL) or the end\n // of the path (if we've matched to the end). We used to do this with a\n // word boundary but that gives false positives on routes like\n // /user-preferences since `-` counts as a word boundary.\n regexpSource += \"(?:(?=\\\\/|$))\";\n } else {\n // Nothing to match for \"\" or \"/\"\n }\n\n let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n return [matcher, paramNames];\n}\n\nfunction safelyDecodeURI(value: string) {\n try {\n return decodeURI(value);\n } catch (error) {\n warning(\n false,\n `The URL path \"${value}\" could not be decoded because it is is a ` +\n `malformed URL segment. This is probably due to a bad percent ` +\n `encoding (${error}).`\n );\n\n return value;\n }\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n try {\n return decodeURIComponent(value);\n } catch (error) {\n warning(\n false,\n `The value for the URL param \"${paramName}\" will not be decoded because` +\n ` the string \"${value}\" is a malformed URL segment. This is probably` +\n ` due to a bad percent encoding (${error}).`\n );\n\n return value;\n }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n pathname: string,\n basename: string\n): string | null {\n if (basename === \"/\") return pathname;\n\n if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n return null;\n }\n\n // We want to leave trailing slash behavior in the user's control, so if they\n // specify a basename with a trailing slash, we should support it\n let startIndex = basename.endsWith(\"/\")\n ? basename.length - 1\n : basename.length;\n let nextChar = pathname.charAt(startIndex);\n if (nextChar && nextChar !== \"/\") {\n // pathname does not start with basename/\n return null;\n }\n\n return pathname.slice(startIndex) || \"/\";\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n let {\n pathname: toPathname,\n search = \"\",\n hash = \"\",\n } = typeof to === \"string\" ? parsePath(to) : to;\n\n let pathname = toPathname\n ? toPathname.startsWith(\"/\")\n ? toPathname\n : resolvePathname(toPathname, fromPathname)\n : fromPathname;\n\n return {\n pathname,\n search: normalizeSearch(search),\n hash: normalizeHash(hash),\n };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n let relativeSegments = relativePath.split(\"/\");\n\n relativeSegments.forEach((segment) => {\n if (segment === \"..\") {\n // Keep the root \"\" segment so the pathname starts at /\n if (segments.length > 1) segments.pop();\n } else if (segment !== \".\") {\n segments.push(segment);\n }\n });\n\n return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction getInvalidPathError(\n char: string,\n field: string,\n dest: string,\n path: Partial\n) {\n return (\n `Cannot include a '${char}' character in a manually specified ` +\n `\\`to.${field}\\` field [${JSON.stringify(\n path\n )}]. Please separate it out to the ` +\n `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n `a string in and the router will parse it for you.`\n );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same. Both of the following examples should link back to the root:\n *\n * \n * \n * \n *\n * \n * \n * }> // <-- Does not contribute\n * // <-- Does not contribute\n * \n * \n */\nexport function getPathContributingMatches<\n T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n return matches.filter(\n (match, index) =>\n index === 0 || (match.route.path && match.route.path.length > 0)\n );\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n toArg: To,\n routePathnames: string[],\n locationPathname: string,\n isPathRelative = false\n): Path {\n let to: Partial;\n if (typeof toArg === \"string\") {\n to = parsePath(toArg);\n } else {\n to = { ...toArg };\n\n invariant(\n !to.pathname || !to.pathname.includes(\"?\"),\n getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n );\n invariant(\n !to.pathname || !to.pathname.includes(\"#\"),\n getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n );\n invariant(\n !to.search || !to.search.includes(\"#\"),\n getInvalidPathError(\"#\", \"search\", \"hash\", to)\n );\n }\n\n let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n let from: string;\n\n // Routing is relative to the current pathname if explicitly requested.\n //\n // If a pathname is explicitly provided in `to`, it should be relative to the\n // route context. This is explained in `Note on `` values` in our\n // migration guide from v5 as a means of disambiguation between `to` values\n // that begin with `/` and those that do not. However, this is problematic for\n // `to` values that do not provide a pathname. `to` can simply be a search or\n // hash string, in which case we should assume that the navigation is relative\n // to the current location's pathname and *not* the route pathname.\n if (isPathRelative || toPathname == null) {\n from = locationPathname;\n } else {\n let routePathnameIndex = routePathnames.length - 1;\n\n if (toPathname.startsWith(\"..\")) {\n let toSegments = toPathname.split(\"/\");\n\n // Each leading .. segment means \"go up one route\" instead of \"go up one\n // URL segment\". This is a key difference from how works and a\n // major reason we call this a \"to\" value instead of a \"href\".\n while (toSegments[0] === \"..\") {\n toSegments.shift();\n routePathnameIndex -= 1;\n }\n\n to.pathname = toSegments.join(\"/\");\n }\n\n // If there are more \"..\" segments than parent routes, resolve relative to\n // the root / URL.\n from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n }\n\n let path = resolvePath(to, from);\n\n // Ensure the pathname has a trailing slash if the original \"to\" had one\n let hasExplicitTrailingSlash =\n toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n // Or if this was a link to the current path which has a trailing slash\n let hasCurrentTrailingSlash =\n (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n if (\n !path.pathname.endsWith(\"/\") &&\n (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n ) {\n path.pathname += \"/\";\n }\n\n return path;\n}\n\n/**\n * @private\n */\nexport function getToPathname(to: To): string | undefined {\n // Empty strings should be treated the same as / paths\n return to === \"\" || (to as Path).pathname === \"\"\n ? \"/\"\n : typeof to === \"string\"\n ? parsePath(to).pathname\n : to.pathname;\n}\n\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n !search || search === \"?\"\n ? \"\"\n : search.startsWith(\"?\")\n ? search\n : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = (\n data: Data,\n init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n let headers = new Headers(responseInit.headers);\n if (!headers.has(\"Content-Type\")) {\n headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n }\n\n return new Response(JSON.stringify(data), {\n ...responseInit,\n headers,\n });\n};\n\nexport interface TrackedPromise extends Promise {\n _tracked?: boolean;\n _data?: any;\n _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n private pendingKeysSet: Set = new Set();\n private controller: AbortController;\n private abortPromise: Promise;\n private unlistenAbortSignal: () => void;\n private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n new Set();\n data: Record;\n init?: ResponseInit;\n deferredKeys: string[] = [];\n\n constructor(data: Record, responseInit?: ResponseInit) {\n invariant(\n data && typeof data === \"object\" && !Array.isArray(data),\n \"defer() only accepts plain objects\"\n );\n\n // Set up an AbortController + Promise we can race against to exit early\n // cancellation\n let reject: (e: AbortedDeferredError) => void;\n this.abortPromise = new Promise((_, r) => (reject = r));\n this.controller = new AbortController();\n let onAbort = () =>\n reject(new AbortedDeferredError(\"Deferred data aborted\"));\n this.unlistenAbortSignal = () =>\n this.controller.signal.removeEventListener(\"abort\", onAbort);\n this.controller.signal.addEventListener(\"abort\", onAbort);\n\n this.data = Object.entries(data).reduce(\n (acc, [key, value]) =>\n Object.assign(acc, {\n [key]: this.trackPromise(key, value),\n }),\n {}\n );\n\n if (this.done) {\n // All incoming values were resolved\n this.unlistenAbortSignal();\n }\n\n this.init = responseInit;\n }\n\n private trackPromise(\n key: string,\n value: Promise | unknown\n ): TrackedPromise | unknown {\n if (!(value instanceof Promise)) {\n return value;\n }\n\n this.deferredKeys.push(key);\n this.pendingKeysSet.add(key);\n\n // We store a little wrapper promise that will be extended with\n // _data/_error props upon resolve/reject\n let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n (data) => this.onSettle(promise, key, undefined, data as unknown),\n (error) => this.onSettle(promise, key, error as unknown)\n );\n\n // Register rejection listeners to avoid uncaught promise rejections on\n // errors or aborted deferred values\n promise.catch(() => {});\n\n Object.defineProperty(promise, \"_tracked\", { get: () => true });\n return promise;\n }\n\n private onSettle(\n promise: TrackedPromise,\n key: string,\n error: unknown,\n data?: unknown\n ): unknown {\n if (\n this.controller.signal.aborted &&\n error instanceof AbortedDeferredError\n ) {\n this.unlistenAbortSignal();\n Object.defineProperty(promise, \"_error\", { get: () => error });\n return Promise.reject(error);\n }\n\n this.pendingKeysSet.delete(key);\n\n if (this.done) {\n // Nothing left to abort!\n this.unlistenAbortSignal();\n }\n\n // If the promise was resolved/rejected with undefined, we'll throw an error as you\n // should always resolve with a value or null\n if (error === undefined && data === undefined) {\n let undefinedError = new Error(\n `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n `you must resolve/reject with a value or \\`null\\`.`\n );\n Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n this.emit(false, key);\n return Promise.reject(undefinedError);\n }\n\n if (data === undefined) {\n Object.defineProperty(promise, \"_error\", { get: () => error });\n this.emit(false, key);\n return Promise.reject(error);\n }\n\n Object.defineProperty(promise, \"_data\", { get: () => data });\n this.emit(false, key);\n return data;\n }\n\n private emit(aborted: boolean, settledKey?: string) {\n this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n }\n\n subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n this.subscribers.add(fn);\n return () => this.subscribers.delete(fn);\n }\n\n cancel() {\n this.controller.abort();\n this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n this.emit(true);\n }\n\n async resolveData(signal: AbortSignal) {\n let aborted = false;\n if (!this.done) {\n let onAbort = () => this.cancel();\n signal.addEventListener(\"abort\", onAbort);\n aborted = await new Promise((resolve) => {\n this.subscribe((aborted) => {\n signal.removeEventListener(\"abort\", onAbort);\n if (aborted || this.done) {\n resolve(aborted);\n }\n });\n });\n }\n return aborted;\n }\n\n get done() {\n return this.pendingKeysSet.size === 0;\n }\n\n get unwrappedData() {\n invariant(\n this.data !== null && this.done,\n \"Can only unwrap data on initialized and settled deferreds\"\n );\n\n return Object.entries(this.data).reduce(\n (acc, [key, value]) =>\n Object.assign(acc, {\n [key]: unwrapTrackedPromise(value),\n }),\n {}\n );\n }\n\n get pendingKeys() {\n return Array.from(this.pendingKeysSet);\n }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n return (\n value instanceof Promise && (value as TrackedPromise)._tracked === true\n );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n if (!isTrackedPromise(value)) {\n return value;\n }\n\n if (value._error) {\n throw value._error;\n }\n return value._data;\n}\n\nexport type DeferFunction = (\n data: Record,\n init?: number | ResponseInit\n) => DeferredData;\n\nexport const defer: DeferFunction = (data, init = {}) => {\n let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n url: string,\n init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n let responseInit = init;\n if (typeof responseInit === \"number\") {\n responseInit = { status: responseInit };\n } else if (typeof responseInit.status === \"undefined\") {\n responseInit.status = 302;\n }\n\n let headers = new Headers(responseInit.headers);\n headers.set(\"Location\", url);\n\n return new Response(null, {\n ...responseInit,\n headers,\n });\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n */\nexport class ErrorResponse {\n status: number;\n statusText: string;\n data: any;\n error?: Error;\n internal: boolean;\n\n constructor(\n status: number,\n statusText: string | undefined,\n data: any,\n internal = false\n ) {\n this.status = status;\n this.statusText = statusText || \"\";\n this.internal = internal;\n if (data instanceof Error) {\n this.data = data.toString();\n this.error = data;\n } else {\n this.data = data;\n }\n }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n return (\n error != null &&\n typeof error.status === \"number\" &&\n typeof error.statusText === \"string\" &&\n typeof error.internal === \"boolean\" &&\n \"data\" in error\n );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n Action as HistoryAction,\n createLocation,\n createPath,\n invariant,\n parsePath,\n warning,\n} from \"./history\";\nimport type {\n DataResult,\n DeferredData,\n AgnosticDataRouteMatch,\n AgnosticDataRouteObject,\n DeferredResult,\n ErrorResult,\n FormEncType,\n FormMethod,\n DetectErrorBoundaryFunction,\n RedirectResult,\n RouteData,\n AgnosticRouteObject,\n Submission,\n SuccessResult,\n AgnosticRouteMatch,\n ShouldRevalidateFunction,\n RouteManifest,\n ImmutableRouteKey,\n ActionFunction,\n LoaderFunction,\n V7_MutationFormMethod,\n V7_FormMethod,\n HTMLFormMethod,\n MutationFormMethod,\n MapRoutePropertiesFunction,\n} from \"./utils\";\nimport {\n ErrorResponse,\n ResultType,\n convertRoutesToDataRoutes,\n getPathContributingMatches,\n immutableRouteKeys,\n isRouteErrorResponse,\n joinPaths,\n matchRoutes,\n resolveTo,\n stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the basename for the router\n */\n get basename(): RouterInit[\"basename\"];\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the current state of the router\n */\n get state(): RouterState;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Return the routes for this router instance\n */\n get routes(): AgnosticDataRouteObject[];\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Initialize the router, including adding history listeners and kicking off\n * initial data fetches. Returns a function to cleanup listeners and abort\n * any in-progress loads\n */\n initialize(): Router;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Subscribe to router.state updates\n *\n * @param fn function to call with the new state\n */\n subscribe(fn: RouterSubscriber): () => void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Enable scroll restoration behavior in the router\n *\n * @param savedScrollPositions Object that will manage positions, in case\n * it's being restored from sessionStorage\n * @param getScrollPosition Function to get the active Y scroll position\n * @param getKey Function to get the key to use for restoration\n */\n enableScrollRestoration(\n savedScrollPositions: Record,\n getScrollPosition: GetScrollPositionFunction,\n getKey?: GetScrollRestorationKeyFunction\n ): () => void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Navigate forward/backward in the history stack\n * @param to Delta to move in the history stack\n */\n navigate(to: number): Promise;\n\n /**\n * Navigate to the given path\n * @param to Path to navigate to\n * @param opts Navigation options (method, submission, etc.)\n */\n navigate(to: To | null, opts?: RouterNavigateOptions): Promise;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Trigger a fetcher load/submission\n *\n * @param key Fetcher key\n * @param routeId Route that owns the fetcher\n * @param href href to fetch\n * @param opts Fetcher options, (method, submission, etc.)\n */\n fetch(\n key: string,\n routeId: string,\n href: string | null,\n opts?: RouterFetchOptions\n ): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Trigger a revalidation of all current route loaders and fetcher loads\n */\n revalidate(): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Utility function to create an href for the given location\n * @param location\n */\n createHref(location: Location | URL): string;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Utility function to URL encode a destination path according to the internal\n * history implementation\n * @param to\n */\n encodeLocation(to: To): Path;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Get/create a fetcher for the given key\n * @param key\n */\n getFetcher(key?: string): Fetcher;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Delete the fetcher for a given key\n * @param key\n */\n deleteFetcher(key?: string): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Cleanup listeners and abort any in-progress loads\n */\n dispose(): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Get a navigation blocker\n * @param key The identifier for the blocker\n * @param fn The blocker function implementation\n */\n getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Delete a navigation blocker\n * @param key The identifier for the blocker\n */\n deleteBlocker(key: string): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * HMR needs to pass in-flight route updates to React Router\n * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n */\n _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Internal fetch AbortControllers accessed by unit tests\n */\n _internalFetchControllers: Map;\n\n /**\n * @internal\n * PRIVATE - DO NOT USE\n *\n * Internal pending DeferredData instances accessed by unit tests\n */\n _internalActiveDeferreds: Map;\n}\n\n/**\n * State maintained internally by the router. During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n /**\n * The action of the most recent navigation\n */\n historyAction: HistoryAction;\n\n /**\n * The current location reflected by the router\n */\n location: Location;\n\n /**\n * The current set of route matches\n */\n matches: AgnosticDataRouteMatch[];\n\n /**\n * Tracks whether we've completed our initial data load\n */\n initialized: boolean;\n\n /**\n * Current scroll position we should start at for a new view\n * - number -> scroll position to restore to\n * - false -> do not restore scroll at all (used during submissions)\n * - null -> don't have a saved position, scroll to hash or top of page\n */\n restoreScrollPosition: number | false | null;\n\n /**\n * Indicate whether this navigation should skip resetting the scroll position\n * if we are unable to restore the scroll position\n */\n preventScrollReset: boolean;\n\n /**\n * Tracks the state of the current navigation\n */\n navigation: Navigation;\n\n /**\n * Tracks any in-progress revalidations\n */\n revalidation: RevalidationState;\n\n /**\n * Data from the loaders for the current matches\n */\n loaderData: RouteData;\n\n /**\n * Data from the action for the current matches\n */\n actionData: RouteData | null;\n\n /**\n * Errors caught from loaders for the current matches\n */\n errors: RouteData | null;\n\n /**\n * Map of current fetchers\n */\n fetchers: Map;\n\n /**\n * Map of current blockers\n */\n blockers: Map;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n Pick\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n v7_normalizeFormMethod: boolean;\n v7_prependBasename: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n routes: AgnosticRouteObject[];\n history: History;\n basename?: string;\n /**\n * @deprecated Use `mapRouteProperties` instead\n */\n detectErrorBoundary?: DetectErrorBoundaryFunction;\n mapRouteProperties?: MapRoutePropertiesFunction;\n future?: Partial;\n hydrationData?: HydrationState;\n window?: Window;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n basename: Router[\"basename\"];\n location: RouterState[\"location\"];\n matches: RouterState[\"matches\"];\n loaderData: RouterState[\"loaderData\"];\n actionData: RouterState[\"actionData\"];\n errors: RouterState[\"errors\"];\n statusCode: number;\n loaderHeaders: Record;\n actionHeaders: Record;\n activeDeferreds: Record | null;\n _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n dataRoutes: AgnosticDataRouteObject[];\n query(\n request: Request,\n opts?: { requestContext?: unknown }\n ): Promise;\n queryRoute(\n request: Request,\n opts?: { routeId?: string; requestContext?: unknown }\n ): Promise;\n}\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n (state: RouterState): void;\n}\n\ninterface UseMatchesMatch {\n id: string;\n pathname: string;\n params: AgnosticRouteMatch[\"params\"];\n data: unknown;\n handle: unknown;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n (location: Location, matches: UseMatchesMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n preventScrollReset?: boolean;\n relative?: RelativeRoutingType;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n replace?: boolean;\n state?: any;\n fromRouteId?: string;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n formMethod?: HTMLFormMethod;\n formEncType?: FormEncType;\n} & (\n | { formData: FormData; body?: undefined }\n | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n | LinkNavigateOptions\n | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n Idle: {\n state: \"idle\";\n location: undefined;\n formMethod: undefined;\n formAction: undefined;\n formEncType: undefined;\n formData: undefined;\n json: undefined;\n text: undefined;\n };\n Loading: {\n state: \"loading\";\n location: Location;\n formMethod: Submission[\"formMethod\"] | undefined;\n formAction: Submission[\"formAction\"] | undefined;\n formEncType: Submission[\"formEncType\"] | undefined;\n formData: Submission[\"formData\"] | undefined;\n json: Submission[\"json\"] | undefined;\n text: Submission[\"text\"] | undefined;\n };\n Submitting: {\n state: \"submitting\";\n location: Location;\n formMethod: Submission[\"formMethod\"];\n formAction: Submission[\"formAction\"];\n formEncType: Submission[\"formEncType\"];\n formData: Submission[\"formData\"];\n json: Submission[\"json\"];\n text: Submission[\"text\"];\n };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates = {\n Idle: {\n state: \"idle\";\n formMethod: undefined;\n formAction: undefined;\n formEncType: undefined;\n text: undefined;\n formData: undefined;\n json: undefined;\n data: TData | undefined;\n \" _hasFetcherDoneAnything \"?: boolean;\n };\n Loading: {\n state: \"loading\";\n formMethod: Submission[\"formMethod\"] | undefined;\n formAction: Submission[\"formAction\"] | undefined;\n formEncType: Submission[\"formEncType\"] | undefined;\n text: Submission[\"text\"] | undefined;\n formData: Submission[\"formData\"] | undefined;\n json: Submission[\"json\"] | undefined;\n data: TData | undefined;\n \" _hasFetcherDoneAnything \"?: boolean;\n };\n Submitting: {\n state: \"submitting\";\n formMethod: Submission[\"formMethod\"];\n formAction: Submission[\"formAction\"];\n formEncType: Submission[\"formEncType\"];\n text: Submission[\"text\"];\n formData: Submission[\"formData\"];\n json: Submission[\"json\"];\n data: TData | undefined;\n \" _hasFetcherDoneAnything \"?: boolean;\n };\n};\n\nexport type Fetcher =\n FetcherStates[keyof FetcherStates];\n\ninterface BlockerBlocked {\n state: \"blocked\";\n reset(): void;\n proceed(): void;\n location: Location;\n}\n\ninterface BlockerUnblocked {\n state: \"unblocked\";\n reset: undefined;\n proceed: undefined;\n location: undefined;\n}\n\ninterface BlockerProceeding {\n state: \"proceeding\";\n reset: undefined;\n proceed: undefined;\n location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n currentLocation: Location;\n nextLocation: Location;\n historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n /**\n * startNavigation does not need to complete the navigation because we\n * redirected or got interrupted\n */\n shortCircuited?: boolean;\n}\n\ninterface HandleActionResult extends ShortCircuitable {\n /**\n * Error thrown from the current action, keyed by the route containing the\n * error boundary to render the error. To be committed to the state after\n * loaders have completed\n */\n pendingActionError?: RouteData;\n /**\n * Data returned from the current action, keyed by the route owning the action.\n * To be committed to the state after loaders have completed\n */\n pendingActionData?: RouteData;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n /**\n * loaderData returned from the current set of loaders\n */\n loaderData?: RouterState[\"loaderData\"];\n /**\n * errors thrown from the current set of loaders\n */\n errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n routeId: string;\n path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n key: string;\n match: AgnosticDataRouteMatch | null;\n matches: AgnosticDataRouteMatch[] | null;\n controller: AbortController | null;\n}\n\n/**\n * Wrapper object to allow us to throw any response out from callLoaderOrAction\n * for queryRouter while preserving whether or not it was thrown or returned\n * from the loader/action\n */\ninterface QueryRouteResponse {\n type: ResultType.data | ResultType.error;\n response: Response;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n \"post\",\n \"put\",\n \"patch\",\n \"delete\",\n];\nconst validMutationMethods = new Set(\n validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n \"get\",\n ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n state: \"idle\",\n location: undefined,\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n state: \"idle\",\n data: undefined,\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n state: \"unblocked\",\n proceed: undefined,\n reset: undefined,\n location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n const routerWindow = init.window\n ? init.window\n : typeof window !== \"undefined\"\n ? window\n : undefined;\n const isBrowser =\n typeof routerWindow !== \"undefined\" &&\n typeof routerWindow.document !== \"undefined\" &&\n typeof routerWindow.document.createElement !== \"undefined\";\n const isServer = !isBrowser;\n\n invariant(\n init.routes.length > 0,\n \"You must provide a non-empty routes array to createRouter\"\n );\n\n let mapRouteProperties: MapRoutePropertiesFunction;\n if (init.mapRouteProperties) {\n mapRouteProperties = init.mapRouteProperties;\n } else if (init.detectErrorBoundary) {\n // If they are still using the deprecated version, wrap it with the new API\n let detectErrorBoundary = init.detectErrorBoundary;\n mapRouteProperties = (route) => ({\n hasErrorBoundary: detectErrorBoundary(route),\n });\n } else {\n mapRouteProperties = defaultMapRouteProperties;\n }\n\n // Routes keyed by ID\n let manifest: RouteManifest = {};\n // Routes in tree format for matching\n let dataRoutes = convertRoutesToDataRoutes(\n init.routes,\n mapRouteProperties,\n undefined,\n manifest\n );\n let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n let basename = init.basename || \"/\";\n // Config driven behavior flags\n let future: FutureConfig = {\n v7_normalizeFormMethod: false,\n v7_prependBasename: false,\n ...init.future,\n };\n // Cleanup function for history\n let unlistenHistory: (() => void) | null = null;\n // Externally-provided functions to call on all state changes\n let subscribers = new Set();\n // Externally-provided object to hold scroll restoration locations during routing\n let savedScrollPositions: Record | null = null;\n // Externally-provided function to get scroll restoration keys\n let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n // Externally-provided function to get current scroll position\n let getScrollPosition: GetScrollPositionFunction | null = null;\n // One-time flag to control the initial hydration scroll restoration. Because\n // we don't get the saved positions from until _after_\n // the initial render, we need to manually trigger a separate updateState to\n // send along the restoreScrollPosition\n // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n // SSR did the initial scroll restoration.\n let initialScrollRestored = init.hydrationData != null;\n\n let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n let initialErrors: RouteData | null = null;\n\n if (initialMatches == null) {\n // If we do not match a user-provided-route, fall back to the root\n // to allow the error boundary to take over\n let error = getInternalRouterError(404, {\n pathname: init.history.location.pathname,\n });\n let { matches, route } = getShortCircuitMatches(dataRoutes);\n initialMatches = matches;\n initialErrors = { [route.id]: error };\n }\n\n let initialized =\n // All initialMatches need to be loaded before we're ready. If we have lazy\n // functions around still then we'll need to run them in initialize()\n !initialMatches.some((m) => m.route.lazy) &&\n // And we have to either have no loaders or have been provided hydrationData\n (!initialMatches.some((m) => m.route.loader) || init.hydrationData != null);\n\n let router: Router;\n let state: RouterState = {\n historyAction: init.history.action,\n location: init.history.location,\n matches: initialMatches,\n initialized,\n navigation: IDLE_NAVIGATION,\n // Don't restore on initial updateState() if we were SSR'd\n restoreScrollPosition: init.hydrationData != null ? false : null,\n preventScrollReset: false,\n revalidation: \"idle\",\n loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n fetchers: new Map(),\n blockers: new Map(),\n };\n\n // -- Stateful internal variables to manage navigations --\n // Current navigation in progress (to be committed in completeNavigation)\n let pendingAction: HistoryAction = HistoryAction.Pop;\n\n // Should the current navigation prevent the scroll reset if scroll cannot\n // be restored?\n let pendingPreventScrollReset = false;\n\n // AbortController for the active navigation\n let pendingNavigationController: AbortController | null;\n\n // We use this to avoid touching history in completeNavigation if a\n // revalidation is entirely uninterrupted\n let isUninterruptedRevalidation = false;\n\n // Use this internal flag to force revalidation of all loaders:\n // - submissions (completed or interrupted)\n // - useRevalidator()\n // - X-Remix-Revalidate (from redirect)\n let isRevalidationRequired = false;\n\n // Use this internal array to capture routes that require revalidation due\n // to a cancelled deferred on action submission\n let cancelledDeferredRoutes: string[] = [];\n\n // Use this internal array to capture fetcher loads that were cancelled by an\n // action navigation and require revalidation\n let cancelledFetcherLoads: string[] = [];\n\n // AbortControllers for any in-flight fetchers\n let fetchControllers = new Map();\n\n // Track loads based on the order in which they started\n let incrementingLoadId = 0;\n\n // Track the outstanding pending navigation data load to be compared against\n // the globally incrementing load when a fetcher load lands after a completed\n // navigation\n let pendingNavigationLoadId = -1;\n\n // Fetchers that triggered data reloads as a result of their actions\n let fetchReloadIds = new Map();\n\n // Fetchers that triggered redirect navigations\n let fetchRedirectIds = new Set();\n\n // Most recent href/match for fetcher.load calls for fetchers\n let fetchLoadMatches = new Map();\n\n // Store DeferredData instances for active route matches. When a\n // route loader returns defer() we stick one in here. Then, when a nested\n // promise resolves we update loaderData. If a new navigation starts we\n // cancel active deferreds for eliminated routes.\n let activeDeferreds = new Map();\n\n // Store blocker functions in a separate Map outside of router state since\n // we don't need to update UI state if they change\n let blockerFunctions = new Map();\n\n // Flag to ignore the next history update, so we can revert the URL change on\n // a POP navigation that was blocked by the user without touching router state\n let ignoreNextHistoryUpdate = false;\n\n // Initialize the router, all side effects should be kicked off from here.\n // Implemented as a Fluent API for ease of:\n // let router = createRouter(init).initialize();\n function initialize() {\n // If history informs us of a POP navigation, start the navigation but do not update\n // state. We'll update our own state once the navigation completes\n unlistenHistory = init.history.listen(\n ({ action: historyAction, location, delta }) => {\n // Ignore this event if it was just us resetting the URL from a\n // blocked POP navigation\n if (ignoreNextHistoryUpdate) {\n ignoreNextHistoryUpdate = false;\n return;\n }\n\n warning(\n blockerFunctions.size === 0 || delta != null,\n \"You are trying to use a blocker on a POP navigation to a location \" +\n \"that was not created by @remix-run/router. This will fail silently in \" +\n \"production. This can happen if you are navigating outside the router \" +\n \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n \"router navigation APIs. This can also happen if you are using \" +\n \"createHashRouter and the user manually changes the URL.\"\n );\n\n let blockerKey = shouldBlockNavigation({\n currentLocation: state.location,\n nextLocation: location,\n historyAction,\n });\n\n if (blockerKey && delta != null) {\n // Restore the URL to match the current UI, but don't update router state\n ignoreNextHistoryUpdate = true;\n init.history.go(delta * -1);\n\n // Put the blocker into a blocked state\n updateBlocker(blockerKey, {\n state: \"blocked\",\n location,\n proceed() {\n updateBlocker(blockerKey!, {\n state: \"proceeding\",\n proceed: undefined,\n reset: undefined,\n location,\n });\n // Re-do the same POP navigation we just blocked\n init.history.go(delta);\n },\n reset() {\n let blockers = new Map(state.blockers);\n blockers.set(blockerKey!, IDLE_BLOCKER);\n updateState({ blockers });\n },\n });\n return;\n }\n\n return startNavigation(historyAction, location);\n }\n );\n\n // Kick off initial data load if needed. Use Pop to avoid modifying history\n // Note we don't do any handling of lazy here. For SPA's it'll get handled\n // in the normal navigation flow. For SSR it's expected that lazy modules are\n // resolved prior to router creation since we can't go into a fallbackElement\n // UI for SSR'd apps\n if (!state.initialized) {\n startNavigation(HistoryAction.Pop, state.location);\n }\n\n return router;\n }\n\n // Clean up a router and it's side effects\n function dispose() {\n if (unlistenHistory) {\n unlistenHistory();\n }\n subscribers.clear();\n pendingNavigationController && pendingNavigationController.abort();\n state.fetchers.forEach((_, key) => deleteFetcher(key));\n state.blockers.forEach((_, key) => deleteBlocker(key));\n }\n\n // Subscribe to state updates for the router\n function subscribe(fn: RouterSubscriber) {\n subscribers.add(fn);\n return () => subscribers.delete(fn);\n }\n\n // Update our state and notify the calling context of the change\n function updateState(newState: Partial): void {\n state = {\n ...state,\n ...newState,\n };\n subscribers.forEach((subscriber) => subscriber(state));\n }\n\n // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n // and setting state.[historyAction/location/matches] to the new route.\n // - Location is a required param\n // - Navigation will always be set to IDLE_NAVIGATION\n // - Can pass any other state in newState\n function completeNavigation(\n location: Location,\n newState: Partial>\n ): void {\n // Deduce if we're in a loading/actionReload state:\n // - We have committed actionData in the store\n // - The current navigation was a mutation submission\n // - We're past the submitting state and into the loading state\n // - The location being loaded is not the result of a redirect\n let isActionReload =\n state.actionData != null &&\n state.navigation.formMethod != null &&\n isMutationMethod(state.navigation.formMethod) &&\n state.navigation.state === \"loading\" &&\n location.state?._isRedirect !== true;\n\n let actionData: RouteData | null;\n if (newState.actionData) {\n if (Object.keys(newState.actionData).length > 0) {\n actionData = newState.actionData;\n } else {\n // Empty actionData -> clear prior actionData due to an action error\n actionData = null;\n }\n } else if (isActionReload) {\n // Keep the current data if we're wrapping up the action reload\n actionData = state.actionData;\n } else {\n // Clear actionData on any other completed navigations\n actionData = null;\n }\n\n // Always preserve any existing loaderData from re-used routes\n let loaderData = newState.loaderData\n ? mergeLoaderData(\n state.loaderData,\n newState.loaderData,\n newState.matches || [],\n newState.errors\n )\n : state.loaderData;\n\n // On a successful navigation we can assume we got through all blockers\n // so we can start fresh\n let blockers = state.blockers;\n if (blockers.size > 0) {\n blockers = new Map(blockers);\n blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n }\n\n // Always respect the user flag. Otherwise don't reset on mutation\n // submission navigations unless they redirect\n let preventScrollReset =\n pendingPreventScrollReset === true ||\n (state.navigation.formMethod != null &&\n isMutationMethod(state.navigation.formMethod) &&\n location.state?._isRedirect !== true);\n\n if (inFlightDataRoutes) {\n dataRoutes = inFlightDataRoutes;\n inFlightDataRoutes = undefined;\n }\n\n if (isUninterruptedRevalidation) {\n // If this was an uninterrupted revalidation then do not touch history\n } else if (pendingAction === HistoryAction.Pop) {\n // Do nothing for POP - URL has already been updated\n } else if (pendingAction === HistoryAction.Push) {\n init.history.push(location, location.state);\n } else if (pendingAction === HistoryAction.Replace) {\n init.history.replace(location, location.state);\n }\n\n updateState({\n ...newState, // matches, errors, fetchers go through as-is\n actionData,\n loaderData,\n historyAction: pendingAction,\n location,\n initialized: true,\n navigation: IDLE_NAVIGATION,\n revalidation: \"idle\",\n restoreScrollPosition: getSavedScrollPosition(\n location,\n newState.matches || state.matches\n ),\n preventScrollReset,\n blockers,\n });\n\n // Reset stateful navigation vars\n pendingAction = HistoryAction.Pop;\n pendingPreventScrollReset = false;\n isUninterruptedRevalidation = false;\n isRevalidationRequired = false;\n cancelledDeferredRoutes = [];\n cancelledFetcherLoads = [];\n }\n\n // Trigger a navigation event, which can either be a numerical POP or a PUSH\n // replace with an optional submission\n async function navigate(\n to: number | To | null,\n opts?: RouterNavigateOptions\n ): Promise {\n if (typeof to === \"number\") {\n init.history.go(to);\n return;\n }\n\n let normalizedPath = normalizeTo(\n state.location,\n state.matches,\n basename,\n future.v7_prependBasename,\n to,\n opts?.fromRouteId,\n opts?.relative\n );\n let { path, submission, error } = normalizeNavigateOptions(\n future.v7_normalizeFormMethod,\n false,\n normalizedPath,\n opts\n );\n\n let currentLocation = state.location;\n let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n // URL from window.location, so we need to encode it here so the behavior\n // remains the same as POP and non-data-router usages. new URL() does all\n // the same encoding we'd get from a history.pushState/window.location read\n // without having to touch history\n nextLocation = {\n ...nextLocation,\n ...init.history.encodeLocation(nextLocation),\n };\n\n let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n let historyAction = HistoryAction.Push;\n\n if (userReplace === true) {\n historyAction = HistoryAction.Replace;\n } else if (userReplace === false) {\n // no-op\n } else if (\n submission != null &&\n isMutationMethod(submission.formMethod) &&\n submission.formAction === state.location.pathname + state.location.search\n ) {\n // By default on submissions to the current location we REPLACE so that\n // users don't have to double-click the back button to get to the prior\n // location. If the user redirects to a different location from the\n // action/loader this will be ignored and the redirect will be a PUSH\n historyAction = HistoryAction.Replace;\n }\n\n let preventScrollReset =\n opts && \"preventScrollReset\" in opts\n ? opts.preventScrollReset === true\n : undefined;\n\n let blockerKey = shouldBlockNavigation({\n currentLocation,\n nextLocation,\n historyAction,\n });\n\n if (blockerKey) {\n // Put the blocker into a blocked state\n updateBlocker(blockerKey, {\n state: \"blocked\",\n location: nextLocation,\n proceed() {\n updateBlocker(blockerKey!, {\n state: \"proceeding\",\n proceed: undefined,\n reset: undefined,\n location: nextLocation,\n });\n // Send the same navigation through\n navigate(to, opts);\n },\n reset() {\n let blockers = new Map(state.blockers);\n blockers.set(blockerKey!, IDLE_BLOCKER);\n updateState({ blockers });\n },\n });\n return;\n }\n\n return await startNavigation(historyAction, nextLocation, {\n submission,\n // Send through the formData serialization error if we have one so we can\n // render at the right error boundary after we match routes\n pendingError: error,\n preventScrollReset,\n replace: opts && opts.replace,\n });\n }\n\n // Revalidate all current loaders. If a navigation is in progress or if this\n // is interrupted by a navigation, allow this to \"succeed\" by calling all\n // loaders during the next loader round\n function revalidate() {\n interruptActiveLoads();\n updateState({ revalidation: \"loading\" });\n\n // If we're currently submitting an action, we don't need to start a new\n // navigation, we'll just let the follow up loader execution call all loaders\n if (state.navigation.state === \"submitting\") {\n return;\n }\n\n // If we're currently in an idle state, start a new navigation for the current\n // action/location and mark it as uninterrupted, which will skip the history\n // update in completeNavigation\n if (state.navigation.state === \"idle\") {\n startNavigation(state.historyAction, state.location, {\n startUninterruptedRevalidation: true,\n });\n return;\n }\n\n // Otherwise, if we're currently in a loading state, just start a new\n // navigation to the navigation.location but do not trigger an uninterrupted\n // revalidation so that history correctly updates once the navigation completes\n startNavigation(\n pendingAction || state.historyAction,\n state.navigation.location,\n { overrideNavigation: state.navigation }\n );\n }\n\n // Start a navigation to the given action/location. Can optionally provide a\n // overrideNavigation which will override the normalLoad in the case of a redirect\n // navigation\n async function startNavigation(\n historyAction: HistoryAction,\n location: Location,\n opts?: {\n submission?: Submission;\n fetcherSubmission?: Submission;\n overrideNavigation?: Navigation;\n pendingError?: ErrorResponse;\n startUninterruptedRevalidation?: boolean;\n preventScrollReset?: boolean;\n replace?: boolean;\n }\n ): Promise {\n // Abort any in-progress navigations and start a new one. Unset any ongoing\n // uninterrupted revalidations unless told otherwise, since we want this\n // new navigation to update history normally\n pendingNavigationController && pendingNavigationController.abort();\n pendingNavigationController = null;\n pendingAction = historyAction;\n isUninterruptedRevalidation =\n (opts && opts.startUninterruptedRevalidation) === true;\n\n // Save the current scroll position every time we start a new navigation,\n // and track whether we should reset scroll on completion\n saveScrollPosition(state.location, state.matches);\n pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let loadingNavigation = opts && opts.overrideNavigation;\n let matches = matchRoutes(routesToUse, location, basename);\n\n // Short circuit with a 404 on the root error boundary if we match nothing\n if (!matches) {\n let error = getInternalRouterError(404, { pathname: location.pathname });\n let { matches: notFoundMatches, route } =\n getShortCircuitMatches(routesToUse);\n // Cancel all pending deferred on 404s since we don't keep any routes\n cancelActiveDeferreds();\n completeNavigation(location, {\n matches: notFoundMatches,\n loaderData: {},\n errors: {\n [route.id]: error,\n },\n });\n return;\n }\n\n // Short circuit if it's only a hash change and not a revalidation or\n // mutation submission.\n //\n // Ignore on initial page loads because since the initial load will always\n // be \"same hash\". For example, on /page#hash and submit a \n // which will default to a navigation to /page\n if (\n state.initialized &&\n !isRevalidationRequired &&\n isHashChangeOnly(state.location, location) &&\n !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n ) {\n completeNavigation(location, { matches });\n return;\n }\n\n // Create a controller/Request for this navigation\n pendingNavigationController = new AbortController();\n let request = createClientSideRequest(\n init.history,\n location,\n pendingNavigationController.signal,\n opts && opts.submission\n );\n let pendingActionData: RouteData | undefined;\n let pendingError: RouteData | undefined;\n\n if (opts && opts.pendingError) {\n // If we have a pendingError, it means the user attempted a GET submission\n // with binary FormData so assign here and skip to handleLoaders. That\n // way we handle calling loaders above the boundary etc. It's not really\n // different from an actionError in that sense.\n pendingError = {\n [findNearestBoundary(matches).route.id]: opts.pendingError,\n };\n } else if (\n opts &&\n opts.submission &&\n isMutationMethod(opts.submission.formMethod)\n ) {\n // Call action if we received an action submission\n let actionOutput = await handleAction(\n request,\n location,\n opts.submission,\n matches,\n { replace: opts.replace }\n );\n\n if (actionOutput.shortCircuited) {\n return;\n }\n\n pendingActionData = actionOutput.pendingActionData;\n pendingError = actionOutput.pendingActionError;\n loadingNavigation = getLoadingNavigation(location, opts.submission);\n\n // Create a GET request for the loaders\n request = new Request(request.url, { signal: request.signal });\n }\n\n // Call loaders\n let { shortCircuited, loaderData, errors } = await handleLoaders(\n request,\n location,\n matches,\n loadingNavigation,\n opts && opts.submission,\n opts && opts.fetcherSubmission,\n opts && opts.replace,\n pendingActionData,\n pendingError\n );\n\n if (shortCircuited) {\n return;\n }\n\n // Clean up now that the action/loaders have completed. Don't clean up if\n // we short circuited because pendingNavigationController will have already\n // been assigned to a new controller for the next navigation\n pendingNavigationController = null;\n\n completeNavigation(location, {\n matches,\n ...(pendingActionData ? { actionData: pendingActionData } : {}),\n loaderData,\n errors,\n });\n }\n\n // Call the action matched by the leaf route for this navigation and handle\n // redirects/errors\n async function handleAction(\n request: Request,\n location: Location,\n submission: Submission,\n matches: AgnosticDataRouteMatch[],\n opts: { replace?: boolean } = {}\n ): Promise {\n interruptActiveLoads();\n\n // Put us in a submitting state\n let navigation = getSubmittingNavigation(location, submission);\n updateState({ navigation });\n\n // Call our action and get the result\n let result: DataResult;\n let actionMatch = getTargetMatch(matches, location);\n\n if (!actionMatch.route.action && !actionMatch.route.lazy) {\n result = {\n type: ResultType.error,\n error: getInternalRouterError(405, {\n method: request.method,\n pathname: location.pathname,\n routeId: actionMatch.route.id,\n }),\n };\n } else {\n result = await callLoaderOrAction(\n \"action\",\n request,\n actionMatch,\n matches,\n manifest,\n mapRouteProperties,\n basename\n );\n\n if (request.signal.aborted) {\n return { shortCircuited: true };\n }\n }\n\n if (isRedirectResult(result)) {\n let replace: boolean;\n if (opts && opts.replace != null) {\n replace = opts.replace;\n } else {\n // If the user didn't explicity indicate replace behavior, replace if\n // we redirected to the exact same location we're currently at to avoid\n // double back-buttons\n replace =\n result.location === state.location.pathname + state.location.search;\n }\n await startRedirectNavigation(state, result, { submission, replace });\n return { shortCircuited: true };\n }\n\n if (isErrorResult(result)) {\n // Store off the pending error - we use it to determine which loaders\n // to call and will commit it when we complete the navigation\n let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n // By default, all submissions are REPLACE navigations, but if the\n // action threw an error that'll be rendered in an errorElement, we fall\n // back to PUSH so that the user can use the back button to get back to\n // the pre-submission form location to try again\n if ((opts && opts.replace) !== true) {\n pendingAction = HistoryAction.Push;\n }\n\n return {\n // Send back an empty object we can use to clear out any prior actionData\n pendingActionData: {},\n pendingActionError: { [boundaryMatch.route.id]: result.error },\n };\n }\n\n if (isDeferredResult(result)) {\n throw getInternalRouterError(400, { type: \"defer-action\" });\n }\n\n return {\n pendingActionData: { [actionMatch.route.id]: result.data },\n };\n }\n\n // Call all applicable loaders for the given matches, handling redirects,\n // errors, etc.\n async function handleLoaders(\n request: Request,\n location: Location,\n matches: AgnosticDataRouteMatch[],\n overrideNavigation?: Navigation,\n submission?: Submission,\n fetcherSubmission?: Submission,\n replace?: boolean,\n pendingActionData?: RouteData,\n pendingError?: RouteData\n ): Promise {\n // Figure out the right navigation we want to use for data loading\n let loadingNavigation =\n overrideNavigation || getLoadingNavigation(location, submission);\n\n // If this was a redirect from an action we don't have a \"submission\" but\n // we have it on the loading navigation so use that if available\n let activeSubmission =\n submission ||\n fetcherSubmission ||\n getSubmissionFromNavigation(loadingNavigation);\n\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n init.history,\n state,\n matches,\n activeSubmission,\n location,\n isRevalidationRequired,\n cancelledDeferredRoutes,\n cancelledFetcherLoads,\n fetchLoadMatches,\n fetchRedirectIds,\n routesToUse,\n basename,\n pendingActionData,\n pendingError\n );\n\n // Cancel pending deferreds for no-longer-matched routes or routes we're\n // about to reload. Note that if this is an action reload we would have\n // already cancelled all pending deferreds so this would be a no-op\n cancelActiveDeferreds(\n (routeId) =>\n !(matches && matches.some((m) => m.route.id === routeId)) ||\n (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n );\n\n pendingNavigationLoadId = ++incrementingLoadId;\n\n // Short circuit if we have no loaders to run\n if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n let updatedFetchers = markFetchRedirectsDone();\n completeNavigation(location, {\n matches,\n loaderData: {},\n // Commit pending error if we're short circuiting\n errors: pendingError || null,\n ...(pendingActionData ? { actionData: pendingActionData } : {}),\n ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n });\n return { shortCircuited: true };\n }\n\n // If this is an uninterrupted revalidation, we remain in our current idle\n // state. If not, we need to switch to our loading state and load data,\n // preserving any new action data or existing action data (in the case of\n // a revalidation interrupting an actionReload)\n if (!isUninterruptedRevalidation) {\n revalidatingFetchers.forEach((rf) => {\n let fetcher = state.fetchers.get(rf.key);\n let revalidatingFetcher = getLoadingFetcher(\n undefined,\n fetcher ? fetcher.data : undefined\n );\n state.fetchers.set(rf.key, revalidatingFetcher);\n });\n let actionData = pendingActionData || state.actionData;\n updateState({\n navigation: loadingNavigation,\n ...(actionData\n ? Object.keys(actionData).length === 0\n ? { actionData: null }\n : { actionData }\n : {}),\n ...(revalidatingFetchers.length > 0\n ? { fetchers: new Map(state.fetchers) }\n : {}),\n });\n }\n\n revalidatingFetchers.forEach((rf) => {\n if (fetchControllers.has(rf.key)) {\n abortFetcher(rf.key);\n }\n if (rf.controller) {\n // Fetchers use an independent AbortController so that aborting a fetcher\n // (via deleteFetcher) does not abort the triggering navigation that\n // triggered the revalidation\n fetchControllers.set(rf.key, rf.controller);\n }\n });\n\n // Proxy navigation abort through to revalidation fetchers\n let abortPendingFetchRevalidations = () =>\n revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n if (pendingNavigationController) {\n pendingNavigationController.signal.addEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n }\n\n let { results, loaderResults, fetcherResults } =\n await callLoadersAndMaybeResolveData(\n state.matches,\n matches,\n matchesToLoad,\n revalidatingFetchers,\n request\n );\n\n if (request.signal.aborted) {\n return { shortCircuited: true };\n }\n\n // Clean up _after_ loaders have completed. Don't clean up if we short\n // circuited because fetchControllers would have been aborted and\n // reassigned to new controllers for the next navigation\n if (pendingNavigationController) {\n pendingNavigationController.signal.removeEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n }\n revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n // If any loaders returned a redirect Response, start a new REPLACE navigation\n let redirect = findRedirect(results);\n if (redirect) {\n if (redirect.idx >= matchesToLoad.length) {\n // If this redirect came from a fetcher make sure we mark it in\n // fetchRedirectIds so it doesn't get revalidated on the next set of\n // loader executions\n let fetcherKey =\n revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n fetchRedirectIds.add(fetcherKey);\n }\n await startRedirectNavigation(state, redirect.result, { replace });\n return { shortCircuited: true };\n }\n\n // Process and commit output from loaders\n let { loaderData, errors } = processLoaderData(\n state,\n matches,\n matchesToLoad,\n loaderResults,\n pendingError,\n revalidatingFetchers,\n fetcherResults,\n activeDeferreds\n );\n\n // Wire up subscribers to update loaderData as promises settle\n activeDeferreds.forEach((deferredData, routeId) => {\n deferredData.subscribe((aborted) => {\n // Note: No need to updateState here since the TrackedPromise on\n // loaderData is stable across resolve/reject\n // Remove this instance if we were aborted or if promises have settled\n if (aborted || deferredData.done) {\n activeDeferreds.delete(routeId);\n }\n });\n });\n\n let updatedFetchers = markFetchRedirectsDone();\n let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n let shouldUpdateFetchers =\n updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n return {\n loaderData,\n errors,\n ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n };\n }\n\n function getFetcher(key: string): Fetcher {\n return state.fetchers.get(key) || IDLE_FETCHER;\n }\n\n // Trigger a fetcher load/submit for the given fetcher key\n function fetch(\n key: string,\n routeId: string,\n href: string | null,\n opts?: RouterFetchOptions\n ) {\n if (isServer) {\n throw new Error(\n \"router.fetch() was called during the server render, but it shouldn't be. \" +\n \"You are likely calling a useFetcher() method in the body of your component. \" +\n \"Try moving it to a useEffect or a callback.\"\n );\n }\n\n if (fetchControllers.has(key)) abortFetcher(key);\n\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let normalizedPath = normalizeTo(\n state.location,\n state.matches,\n basename,\n future.v7_prependBasename,\n href,\n routeId,\n opts?.relative\n );\n let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n if (!matches) {\n setFetcherError(\n key,\n routeId,\n getInternalRouterError(404, { pathname: normalizedPath })\n );\n return;\n }\n\n let { path, submission, error } = normalizeNavigateOptions(\n future.v7_normalizeFormMethod,\n true,\n normalizedPath,\n opts\n );\n\n if (error) {\n setFetcherError(key, routeId, error);\n return;\n }\n\n let match = getTargetMatch(matches, path);\n\n pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n if (submission && isMutationMethod(submission.formMethod)) {\n handleFetcherAction(key, routeId, path, match, matches, submission);\n return;\n }\n\n // Store off the match so we can call it's shouldRevalidate on subsequent\n // revalidations\n fetchLoadMatches.set(key, { routeId, path });\n handleFetcherLoader(key, routeId, path, match, matches, submission);\n }\n\n // Call the action for the matched fetcher.submit(), and then handle redirects,\n // errors, and revalidation\n async function handleFetcherAction(\n key: string,\n routeId: string,\n path: string,\n match: AgnosticDataRouteMatch,\n requestMatches: AgnosticDataRouteMatch[],\n submission: Submission\n ) {\n interruptActiveLoads();\n fetchLoadMatches.delete(key);\n\n if (!match.route.action && !match.route.lazy) {\n let error = getInternalRouterError(405, {\n method: submission.formMethod,\n pathname: path,\n routeId: routeId,\n });\n setFetcherError(key, routeId, error);\n return;\n }\n\n // Put this fetcher into it's submitting state\n let existingFetcher = state.fetchers.get(key);\n let fetcher = getSubmittingFetcher(submission, existingFetcher);\n state.fetchers.set(key, fetcher);\n updateState({ fetchers: new Map(state.fetchers) });\n\n // Call the action for the fetcher\n let abortController = new AbortController();\n let fetchRequest = createClientSideRequest(\n init.history,\n path,\n abortController.signal,\n submission\n );\n fetchControllers.set(key, abortController);\n\n let originatingLoadId = incrementingLoadId;\n let actionResult = await callLoaderOrAction(\n \"action\",\n fetchRequest,\n match,\n requestMatches,\n manifest,\n mapRouteProperties,\n basename\n );\n\n if (fetchRequest.signal.aborted) {\n // We can delete this so long as we weren't aborted by ou our own fetcher\n // re-submit which would have put _new_ controller is in fetchControllers\n if (fetchControllers.get(key) === abortController) {\n fetchControllers.delete(key);\n }\n return;\n }\n\n if (isRedirectResult(actionResult)) {\n fetchControllers.delete(key);\n if (pendingNavigationLoadId > originatingLoadId) {\n // A new navigation was kicked off after our action started, so that\n // should take precedence over this redirect navigation. We already\n // set isRevalidationRequired so all loaders for the new route should\n // fire unless opted out via shouldRevalidate\n let doneFetcher = getDoneFetcher(undefined);\n state.fetchers.set(key, doneFetcher);\n updateState({ fetchers: new Map(state.fetchers) });\n return;\n } else {\n fetchRedirectIds.add(key);\n let loadingFetcher = getLoadingFetcher(submission);\n state.fetchers.set(key, loadingFetcher);\n updateState({ fetchers: new Map(state.fetchers) });\n\n return startRedirectNavigation(state, actionResult, {\n submission,\n isFetchActionRedirect: true,\n });\n }\n }\n\n // Process any non-redirect errors thrown\n if (isErrorResult(actionResult)) {\n setFetcherError(key, routeId, actionResult.error);\n return;\n }\n\n if (isDeferredResult(actionResult)) {\n throw getInternalRouterError(400, { type: \"defer-action\" });\n }\n\n // Start the data load for current matches, or the next location if we're\n // in the middle of a navigation\n let nextLocation = state.navigation.location || state.location;\n let revalidationRequest = createClientSideRequest(\n init.history,\n nextLocation,\n abortController.signal\n );\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let matches =\n state.navigation.state !== \"idle\"\n ? matchRoutes(routesToUse, state.navigation.location, basename)\n : state.matches;\n\n invariant(matches, \"Didn't find any matches after fetcher action\");\n\n let loadId = ++incrementingLoadId;\n fetchReloadIds.set(key, loadId);\n\n let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n state.fetchers.set(key, loadFetcher);\n\n let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n init.history,\n state,\n matches,\n submission,\n nextLocation,\n isRevalidationRequired,\n cancelledDeferredRoutes,\n cancelledFetcherLoads,\n fetchLoadMatches,\n fetchRedirectIds,\n routesToUse,\n basename,\n { [match.route.id]: actionResult.data },\n undefined // No need to send through errors since we short circuit above\n );\n\n // Put all revalidating fetchers into the loading state, except for the\n // current fetcher which we want to keep in it's current loading state which\n // contains it's action submission info + action data\n revalidatingFetchers\n .filter((rf) => rf.key !== key)\n .forEach((rf) => {\n let staleKey = rf.key;\n let existingFetcher = state.fetchers.get(staleKey);\n let revalidatingFetcher = getLoadingFetcher(\n undefined,\n existingFetcher ? existingFetcher.data : undefined\n );\n state.fetchers.set(staleKey, revalidatingFetcher);\n if (fetchControllers.has(staleKey)) {\n abortFetcher(staleKey);\n }\n if (rf.controller) {\n fetchControllers.set(staleKey, rf.controller);\n }\n });\n\n updateState({ fetchers: new Map(state.fetchers) });\n\n let abortPendingFetchRevalidations = () =>\n revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n abortController.signal.addEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n\n let { results, loaderResults, fetcherResults } =\n await callLoadersAndMaybeResolveData(\n state.matches,\n matches,\n matchesToLoad,\n revalidatingFetchers,\n revalidationRequest\n );\n\n if (abortController.signal.aborted) {\n return;\n }\n\n abortController.signal.removeEventListener(\n \"abort\",\n abortPendingFetchRevalidations\n );\n\n fetchReloadIds.delete(key);\n fetchControllers.delete(key);\n revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n let redirect = findRedirect(results);\n if (redirect) {\n if (redirect.idx >= matchesToLoad.length) {\n // If this redirect came from a fetcher make sure we mark it in\n // fetchRedirectIds so it doesn't get revalidated on the next set of\n // loader executions\n let fetcherKey =\n revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n fetchRedirectIds.add(fetcherKey);\n }\n return startRedirectNavigation(state, redirect.result);\n }\n\n // Process and commit output from loaders\n let { loaderData, errors } = processLoaderData(\n state,\n state.matches,\n matchesToLoad,\n loaderResults,\n undefined,\n revalidatingFetchers,\n fetcherResults,\n activeDeferreds\n );\n\n // Since we let revalidations complete even if the submitting fetcher was\n // deleted, only put it back to idle if it hasn't been deleted\n if (state.fetchers.has(key)) {\n let doneFetcher = getDoneFetcher(actionResult.data);\n state.fetchers.set(key, doneFetcher);\n }\n\n let didAbortFetchLoads = abortStaleFetchLoads(loadId);\n\n // If we are currently in a navigation loading state and this fetcher is\n // more recent than the navigation, we want the newer data so abort the\n // navigation and complete it with the fetcher data\n if (\n state.navigation.state === \"loading\" &&\n loadId > pendingNavigationLoadId\n ) {\n invariant(pendingAction, \"Expected pending action\");\n pendingNavigationController && pendingNavigationController.abort();\n\n completeNavigation(state.navigation.location, {\n matches,\n loaderData,\n errors,\n fetchers: new Map(state.fetchers),\n });\n } else {\n // otherwise just update with the fetcher data, preserving any existing\n // loaderData for loaders that did not need to reload. We have to\n // manually merge here since we aren't going through completeNavigation\n updateState({\n errors,\n loaderData: mergeLoaderData(\n state.loaderData,\n loaderData,\n matches,\n errors\n ),\n ...(didAbortFetchLoads || revalidatingFetchers.length > 0\n ? { fetchers: new Map(state.fetchers) }\n : {}),\n });\n isRevalidationRequired = false;\n }\n }\n\n // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n async function handleFetcherLoader(\n key: string,\n routeId: string,\n path: string,\n match: AgnosticDataRouteMatch,\n matches: AgnosticDataRouteMatch[],\n submission?: Submission\n ) {\n let existingFetcher = state.fetchers.get(key);\n // Put this fetcher into it's loading state\n let loadingFetcher = getLoadingFetcher(\n submission,\n existingFetcher ? existingFetcher.data : undefined\n );\n state.fetchers.set(key, loadingFetcher);\n updateState({ fetchers: new Map(state.fetchers) });\n\n // Call the loader for this fetcher route match\n let abortController = new AbortController();\n let fetchRequest = createClientSideRequest(\n init.history,\n path,\n abortController.signal\n );\n fetchControllers.set(key, abortController);\n\n let originatingLoadId = incrementingLoadId;\n let result: DataResult = await callLoaderOrAction(\n \"loader\",\n fetchRequest,\n match,\n matches,\n manifest,\n mapRouteProperties,\n basename\n );\n\n // Deferred isn't supported for fetcher loads, await everything and treat it\n // as a normal load. resolveDeferredData will return undefined if this\n // fetcher gets aborted, so we just leave result untouched and short circuit\n // below if that happens\n if (isDeferredResult(result)) {\n result =\n (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n result;\n }\n\n // We can delete this so long as we weren't aborted by our our own fetcher\n // re-load which would have put _new_ controller is in fetchControllers\n if (fetchControllers.get(key) === abortController) {\n fetchControllers.delete(key);\n }\n\n if (fetchRequest.signal.aborted) {\n return;\n }\n\n // If the loader threw a redirect Response, start a new REPLACE navigation\n if (isRedirectResult(result)) {\n if (pendingNavigationLoadId > originatingLoadId) {\n // A new navigation was kicked off after our loader started, so that\n // should take precedence over this redirect navigation\n let doneFetcher = getDoneFetcher(undefined);\n state.fetchers.set(key, doneFetcher);\n updateState({ fetchers: new Map(state.fetchers) });\n return;\n } else {\n fetchRedirectIds.add(key);\n await startRedirectNavigation(state, result);\n return;\n }\n }\n\n // Process any non-redirect errors thrown\n if (isErrorResult(result)) {\n let boundaryMatch = findNearestBoundary(state.matches, routeId);\n state.fetchers.delete(key);\n // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -\n // do we need to behave any differently with our non-redirect errors?\n // What if it was a non-redirect Response?\n updateState({\n fetchers: new Map(state.fetchers),\n errors: {\n [boundaryMatch.route.id]: result.error,\n },\n });\n return;\n }\n\n invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n // Put the fetcher back into an idle state\n let doneFetcher = getDoneFetcher(result.data);\n state.fetchers.set(key, doneFetcher);\n updateState({ fetchers: new Map(state.fetchers) });\n }\n\n /**\n * Utility function to handle redirects returned from an action or loader.\n * Normally, a redirect \"replaces\" the navigation that triggered it. So, for\n * example:\n *\n * - user is on /a\n * - user clicks a link to /b\n * - loader for /b redirects to /c\n *\n * In a non-JS app the browser would track the in-flight navigation to /b and\n * then replace it with /c when it encountered the redirect response. In\n * the end it would only ever update the URL bar with /c.\n *\n * In client-side routing using pushState/replaceState, we aim to emulate\n * this behavior and we also do not update history until the end of the\n * navigation (including processed redirects). This means that we never\n * actually touch history until we've processed redirects, so we just use\n * the history action from the original navigation (PUSH or REPLACE).\n */\n async function startRedirectNavigation(\n state: RouterState,\n redirect: RedirectResult,\n {\n submission,\n replace,\n isFetchActionRedirect,\n }: {\n submission?: Submission;\n replace?: boolean;\n isFetchActionRedirect?: boolean;\n } = {}\n ) {\n if (redirect.revalidate) {\n isRevalidationRequired = true;\n }\n\n let redirectLocation = createLocation(\n state.location,\n redirect.location,\n // TODO: This can be removed once we get rid of useTransition in Remix v2\n {\n _isRedirect: true,\n ...(isFetchActionRedirect ? { _isFetchActionRedirect: true } : {}),\n }\n );\n invariant(\n redirectLocation,\n \"Expected a location on the redirect navigation\"\n );\n // Check if this an absolute external redirect that goes to a new origin\n if (ABSOLUTE_URL_REGEX.test(redirect.location) && isBrowser) {\n let url = init.history.createURL(redirect.location);\n let isDifferentBasename = stripBasename(url.pathname, basename) == null;\n\n if (routerWindow.location.origin !== url.origin || isDifferentBasename) {\n if (replace) {\n routerWindow.location.replace(redirect.location);\n } else {\n routerWindow.location.assign(redirect.location);\n }\n return;\n }\n }\n\n // There's no need to abort on redirects, since we don't detect the\n // redirect until the action/loaders have settled\n pendingNavigationController = null;\n\n let redirectHistoryAction =\n replace === true ? HistoryAction.Replace : HistoryAction.Push;\n\n // Use the incoming submission if provided, fallback on the active one in\n // state.navigation\n let activeSubmission =\n submission || getSubmissionFromNavigation(state.navigation);\n\n // If this was a 307/308 submission we want to preserve the HTTP method and\n // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n // redirected location\n if (\n redirectPreserveMethodStatusCodes.has(redirect.status) &&\n activeSubmission &&\n isMutationMethod(activeSubmission.formMethod)\n ) {\n await startNavigation(redirectHistoryAction, redirectLocation, {\n submission: {\n ...activeSubmission,\n formAction: redirect.location,\n },\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset,\n });\n } else if (isFetchActionRedirect) {\n // For a fetch action redirect, we kick off a new loading navigation\n // without the fetcher submission, but we send it along for shouldRevalidate\n await startNavigation(redirectHistoryAction, redirectLocation, {\n overrideNavigation: getLoadingNavigation(redirectLocation),\n fetcherSubmission: activeSubmission,\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset,\n });\n } else {\n // If we have a submission, we will preserve it through the redirect navigation\n let overrideNavigation = getLoadingNavigation(\n redirectLocation,\n activeSubmission\n );\n await startNavigation(redirectHistoryAction, redirectLocation, {\n overrideNavigation,\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset,\n });\n }\n }\n\n async function callLoadersAndMaybeResolveData(\n currentMatches: AgnosticDataRouteMatch[],\n matches: AgnosticDataRouteMatch[],\n matchesToLoad: AgnosticDataRouteMatch[],\n fetchersToLoad: RevalidatingFetcher[],\n request: Request\n ) {\n // Call all navigation loaders and revalidating fetcher loaders in parallel,\n // then slice off the results into separate arrays so we can handle them\n // accordingly\n let results = await Promise.all([\n ...matchesToLoad.map((match) =>\n callLoaderOrAction(\n \"loader\",\n request,\n match,\n matches,\n manifest,\n mapRouteProperties,\n basename\n )\n ),\n ...fetchersToLoad.map((f) => {\n if (f.matches && f.match && f.controller) {\n return callLoaderOrAction(\n \"loader\",\n createClientSideRequest(init.history, f.path, f.controller.signal),\n f.match,\n f.matches,\n manifest,\n mapRouteProperties,\n basename\n );\n } else {\n let error: ErrorResult = {\n type: ResultType.error,\n error: getInternalRouterError(404, { pathname: f.path }),\n };\n return error;\n }\n }),\n ]);\n let loaderResults = results.slice(0, matchesToLoad.length);\n let fetcherResults = results.slice(matchesToLoad.length);\n\n await Promise.all([\n resolveDeferredResults(\n currentMatches,\n matchesToLoad,\n loaderResults,\n loaderResults.map(() => request.signal),\n false,\n state.loaderData\n ),\n resolveDeferredResults(\n currentMatches,\n fetchersToLoad.map((f) => f.match),\n fetcherResults,\n fetchersToLoad.map((f) => (f.controller ? f.controller.signal : null)),\n true\n ),\n ]);\n\n return { results, loaderResults, fetcherResults };\n }\n\n function interruptActiveLoads() {\n // Every interruption triggers a revalidation\n isRevalidationRequired = true;\n\n // Cancel pending route-level deferreds and mark cancelled routes for\n // revalidation\n cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n // Abort in-flight fetcher loads\n fetchLoadMatches.forEach((_, key) => {\n if (fetchControllers.has(key)) {\n cancelledFetcherLoads.push(key);\n abortFetcher(key);\n }\n });\n }\n\n function setFetcherError(key: string, routeId: string, error: any) {\n let boundaryMatch = findNearestBoundary(state.matches, routeId);\n deleteFetcher(key);\n updateState({\n errors: {\n [boundaryMatch.route.id]: error,\n },\n fetchers: new Map(state.fetchers),\n });\n }\n\n function deleteFetcher(key: string): void {\n let fetcher = state.fetchers.get(key);\n // Don't abort the controller if this is a deletion of a fetcher.submit()\n // in it's loading phase since - we don't want to abort the corresponding\n // revalidation and want them to complete and land\n if (\n fetchControllers.has(key) &&\n !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n ) {\n abortFetcher(key);\n }\n fetchLoadMatches.delete(key);\n fetchReloadIds.delete(key);\n fetchRedirectIds.delete(key);\n state.fetchers.delete(key);\n }\n\n function abortFetcher(key: string) {\n let controller = fetchControllers.get(key);\n invariant(controller, `Expected fetch controller: ${key}`);\n controller.abort();\n fetchControllers.delete(key);\n }\n\n function markFetchersDone(keys: string[]) {\n for (let key of keys) {\n let fetcher = getFetcher(key);\n let doneFetcher = getDoneFetcher(fetcher.data);\n state.fetchers.set(key, doneFetcher);\n }\n }\n\n function markFetchRedirectsDone(): boolean {\n let doneKeys = [];\n let updatedFetchers = false;\n for (let key of fetchRedirectIds) {\n let fetcher = state.fetchers.get(key);\n invariant(fetcher, `Expected fetcher: ${key}`);\n if (fetcher.state === \"loading\") {\n fetchRedirectIds.delete(key);\n doneKeys.push(key);\n updatedFetchers = true;\n }\n }\n markFetchersDone(doneKeys);\n return updatedFetchers;\n }\n\n function abortStaleFetchLoads(landedId: number): boolean {\n let yeetedKeys = [];\n for (let [key, id] of fetchReloadIds) {\n if (id < landedId) {\n let fetcher = state.fetchers.get(key);\n invariant(fetcher, `Expected fetcher: ${key}`);\n if (fetcher.state === \"loading\") {\n abortFetcher(key);\n fetchReloadIds.delete(key);\n yeetedKeys.push(key);\n }\n }\n }\n markFetchersDone(yeetedKeys);\n return yeetedKeys.length > 0;\n }\n\n function getBlocker(key: string, fn: BlockerFunction) {\n let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n if (blockerFunctions.get(key) !== fn) {\n blockerFunctions.set(key, fn);\n }\n\n return blocker;\n }\n\n function deleteBlocker(key: string) {\n state.blockers.delete(key);\n blockerFunctions.delete(key);\n }\n\n // Utility function to update blockers, ensuring valid state transitions\n function updateBlocker(key: string, newBlocker: Blocker) {\n let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n // Poor mans state machine :)\n // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n invariant(\n (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n );\n\n let blockers = new Map(state.blockers);\n blockers.set(key, newBlocker);\n updateState({ blockers });\n }\n\n function shouldBlockNavigation({\n currentLocation,\n nextLocation,\n historyAction,\n }: {\n currentLocation: Location;\n nextLocation: Location;\n historyAction: HistoryAction;\n }): string | undefined {\n if (blockerFunctions.size === 0) {\n return;\n }\n\n // We ony support a single active blocker at the moment since we don't have\n // any compelling use cases for multi-blocker yet\n if (blockerFunctions.size > 1) {\n warning(false, \"A router only supports one blocker at a time\");\n }\n\n let entries = Array.from(blockerFunctions.entries());\n let [blockerKey, blockerFunction] = entries[entries.length - 1];\n let blocker = state.blockers.get(blockerKey);\n\n if (blocker && blocker.state === \"proceeding\") {\n // If the blocker is currently proceeding, we don't need to re-check\n // it and can let this navigation continue\n return;\n }\n\n // At this point, we know we're unblocked/blocked so we need to check the\n // user-provided blocker function\n if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n return blockerKey;\n }\n }\n\n function cancelActiveDeferreds(\n predicate?: (routeId: string) => boolean\n ): string[] {\n let cancelledRouteIds: string[] = [];\n activeDeferreds.forEach((dfd, routeId) => {\n if (!predicate || predicate(routeId)) {\n // Cancel the deferred - but do not remove from activeDeferreds here -\n // we rely on the subscribers to do that so our tests can assert proper\n // cleanup via _internalActiveDeferreds\n dfd.cancel();\n cancelledRouteIds.push(routeId);\n activeDeferreds.delete(routeId);\n }\n });\n return cancelledRouteIds;\n }\n\n // Opt in to capturing and reporting scroll positions during navigations,\n // used by the component\n function enableScrollRestoration(\n positions: Record,\n getPosition: GetScrollPositionFunction,\n getKey?: GetScrollRestorationKeyFunction\n ) {\n savedScrollPositions = positions;\n getScrollPosition = getPosition;\n getScrollRestorationKey = getKey || null;\n\n // Perform initial hydration scroll restoration, since we miss the boat on\n // the initial updateState() because we've not yet rendered \n // and therefore have no savedScrollPositions available\n if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n initialScrollRestored = true;\n let y = getSavedScrollPosition(state.location, state.matches);\n if (y != null) {\n updateState({ restoreScrollPosition: y });\n }\n }\n\n return () => {\n savedScrollPositions = null;\n getScrollPosition = null;\n getScrollRestorationKey = null;\n };\n }\n\n function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n if (getScrollRestorationKey) {\n let key = getScrollRestorationKey(\n location,\n matches.map((m) => createUseMatchesMatch(m, state.loaderData))\n );\n return key || location.key;\n }\n return location.key;\n }\n\n function saveScrollPosition(\n location: Location,\n matches: AgnosticDataRouteMatch[]\n ): void {\n if (savedScrollPositions && getScrollPosition) {\n let key = getScrollKey(location, matches);\n savedScrollPositions[key] = getScrollPosition();\n }\n }\n\n function getSavedScrollPosition(\n location: Location,\n matches: AgnosticDataRouteMatch[]\n ): number | null {\n if (savedScrollPositions) {\n let key = getScrollKey(location, matches);\n let y = savedScrollPositions[key];\n if (typeof y === \"number\") {\n return y;\n }\n }\n return null;\n }\n\n function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n manifest = {};\n inFlightDataRoutes = convertRoutesToDataRoutes(\n newRoutes,\n mapRouteProperties,\n undefined,\n manifest\n );\n }\n\n router = {\n get basename() {\n return basename;\n },\n get state() {\n return state;\n },\n get routes() {\n return dataRoutes;\n },\n initialize,\n subscribe,\n enableScrollRestoration,\n navigate,\n fetch,\n revalidate,\n // Passthrough to history-aware createHref used by useHref so we get proper\n // hash-aware URLs in DOM paths\n createHref: (to: To) => init.history.createHref(to),\n encodeLocation: (to: To) => init.history.encodeLocation(to),\n getFetcher,\n deleteFetcher,\n dispose,\n getBlocker,\n deleteBlocker,\n _internalFetchControllers: fetchControllers,\n _internalActiveDeferreds: activeDeferreds,\n // TODO: Remove setRoutes, it's temporary to avoid dealing with\n // updating the tree while validating the update algorithm.\n _internalSetRoutes,\n };\n\n return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\nexport interface CreateStaticHandlerOptions {\n basename?: string;\n /**\n * @deprecated Use `mapRouteProperties` instead\n */\n detectErrorBoundary?: DetectErrorBoundaryFunction;\n mapRouteProperties?: MapRoutePropertiesFunction;\n}\n\nexport function createStaticHandler(\n routes: AgnosticRouteObject[],\n opts?: CreateStaticHandlerOptions\n): StaticHandler {\n invariant(\n routes.length > 0,\n \"You must provide a non-empty routes array to createStaticHandler\"\n );\n\n let manifest: RouteManifest = {};\n let basename = (opts ? opts.basename : null) || \"/\";\n let mapRouteProperties: MapRoutePropertiesFunction;\n if (opts?.mapRouteProperties) {\n mapRouteProperties = opts.mapRouteProperties;\n } else if (opts?.detectErrorBoundary) {\n // If they are still using the deprecated version, wrap it with the new API\n let detectErrorBoundary = opts.detectErrorBoundary;\n mapRouteProperties = (route) => ({\n hasErrorBoundary: detectErrorBoundary(route),\n });\n } else {\n mapRouteProperties = defaultMapRouteProperties;\n }\n\n let dataRoutes = convertRoutesToDataRoutes(\n routes,\n mapRouteProperties,\n undefined,\n manifest\n );\n\n /**\n * The query() method is intended for document requests, in which we want to\n * call an optional action and potentially multiple loaders for all nested\n * routes. It returns a StaticHandlerContext object, which is very similar\n * to the router state (location, loaderData, actionData, errors, etc.) and\n * also adds SSR-specific information such as the statusCode and headers\n * from action/loaders Responses.\n *\n * It _should_ never throw and should report all errors through the\n * returned context.errors object, properly associating errors to their error\n * boundary. Additionally, it tracks _deepestRenderedBoundaryId which can be\n * used to emulate React error boundaries during SSr by performing a second\n * pass only down to the boundaryId.\n *\n * The one exception where we do not return a StaticHandlerContext is when a\n * redirect response is returned or thrown from any action/loader. We\n * propagate that out and return the raw Response so the HTTP server can\n * return it directly.\n */\n async function query(\n request: Request,\n { requestContext }: { requestContext?: unknown } = {}\n ): Promise {\n let url = new URL(request.url);\n let method = request.method;\n let location = createLocation(\"\", createPath(url), null, \"default\");\n let matches = matchRoutes(dataRoutes, location, basename);\n\n // SSR supports HEAD requests while SPA doesn't\n if (!isValidMethod(method) && method !== \"HEAD\") {\n let error = getInternalRouterError(405, { method });\n let { matches: methodNotAllowedMatches, route } =\n getShortCircuitMatches(dataRoutes);\n return {\n basename,\n location,\n matches: methodNotAllowedMatches,\n loaderData: {},\n actionData: null,\n errors: {\n [route.id]: error,\n },\n statusCode: error.status,\n loaderHeaders: {},\n actionHeaders: {},\n activeDeferreds: null,\n };\n } else if (!matches) {\n let error = getInternalRouterError(404, { pathname: location.pathname });\n let { matches: notFoundMatches, route } =\n getShortCircuitMatches(dataRoutes);\n return {\n basename,\n location,\n matches: notFoundMatches,\n loaderData: {},\n actionData: null,\n errors: {\n [route.id]: error,\n },\n statusCode: error.status,\n loaderHeaders: {},\n actionHeaders: {},\n activeDeferreds: null,\n };\n }\n\n let result = await queryImpl(request, location, matches, requestContext);\n if (isResponse(result)) {\n return result;\n }\n\n // When returning StaticHandlerContext, we patch back in the location here\n // since we need it for React Context. But this helps keep our submit and\n // loadRouteData operating on a Request instead of a Location\n return { location, basename, ...result };\n }\n\n /**\n * The queryRoute() method is intended for targeted route requests, either\n * for fetch ?_data requests or resource route requests. In this case, we\n * are only ever calling a single action or loader, and we are returning the\n * returned value directly. In most cases, this will be a Response returned\n * from the action/loader, but it may be a primitive or other value as well -\n * and in such cases the calling context should handle that accordingly.\n *\n * We do respect the throw/return differentiation, so if an action/loader\n * throws, then this method will throw the value. This is important so we\n * can do proper boundary identification in Remix where a thrown Response\n * must go to the Catch Boundary but a returned Response is happy-path.\n *\n * One thing to note is that any Router-initiated Errors that make sense\n * to associate with a status code will be thrown as an ErrorResponse\n * instance which include the raw Error, such that the calling context can\n * serialize the error as they see fit while including the proper response\n * code. Examples here are 404 and 405 errors that occur prior to reaching\n * any user-defined loaders.\n */\n async function queryRoute(\n request: Request,\n {\n routeId,\n requestContext,\n }: { requestContext?: unknown; routeId?: string } = {}\n ): Promise {\n let url = new URL(request.url);\n let method = request.method;\n let location = createLocation(\"\", createPath(url), null, \"default\");\n let matches = matchRoutes(dataRoutes, location, basename);\n\n // SSR supports HEAD requests while SPA doesn't\n if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n throw getInternalRouterError(405, { method });\n } else if (!matches) {\n throw getInternalRouterError(404, { pathname: location.pathname });\n }\n\n let match = routeId\n ? matches.find((m) => m.route.id === routeId)\n : getTargetMatch(matches, location);\n\n if (routeId && !match) {\n throw getInternalRouterError(403, {\n pathname: location.pathname,\n routeId,\n });\n } else if (!match) {\n // This should never hit I don't think?\n throw getInternalRouterError(404, { pathname: location.pathname });\n }\n\n let result = await queryImpl(\n request,\n location,\n matches,\n requestContext,\n match\n );\n if (isResponse(result)) {\n return result;\n }\n\n let error = result.errors ? Object.values(result.errors)[0] : undefined;\n if (error !== undefined) {\n // If we got back result.errors, that means the loader/action threw\n // _something_ that wasn't a Response, but it's not guaranteed/required\n // to be an `instanceof Error` either, so we have to use throw here to\n // preserve the \"error\" state outside of queryImpl.\n throw error;\n }\n\n // Pick off the right state value to return\n if (result.actionData) {\n return Object.values(result.actionData)[0];\n }\n\n if (result.loaderData) {\n let data = Object.values(result.loaderData)[0];\n if (result.activeDeferreds?.[match.route.id]) {\n data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n }\n return data;\n }\n\n return undefined;\n }\n\n async function queryImpl(\n request: Request,\n location: Location,\n matches: AgnosticDataRouteMatch[],\n requestContext: unknown,\n routeMatch?: AgnosticDataRouteMatch\n ): Promise | Response> {\n invariant(\n request.signal,\n \"query()/queryRoute() requests must contain an AbortController signal\"\n );\n\n try {\n if (isMutationMethod(request.method.toLowerCase())) {\n let result = await submit(\n request,\n matches,\n routeMatch || getTargetMatch(matches, location),\n requestContext,\n routeMatch != null\n );\n return result;\n }\n\n let result = await loadRouteData(\n request,\n matches,\n requestContext,\n routeMatch\n );\n return isResponse(result)\n ? result\n : {\n ...result,\n actionData: null,\n actionHeaders: {},\n };\n } catch (e) {\n // If the user threw/returned a Response in callLoaderOrAction, we throw\n // it to bail out and then return or throw here based on whether the user\n // returned or threw\n if (isQueryRouteResponse(e)) {\n if (e.type === ResultType.error && !isRedirectResponse(e.response)) {\n throw e.response;\n }\n return e.response;\n }\n // Redirects are always returned since they don't propagate to catch\n // boundaries\n if (isRedirectResponse(e)) {\n return e;\n }\n throw e;\n }\n }\n\n async function submit(\n request: Request,\n matches: AgnosticDataRouteMatch[],\n actionMatch: AgnosticDataRouteMatch,\n requestContext: unknown,\n isRouteRequest: boolean\n ): Promise | Response> {\n let result: DataResult;\n\n if (!actionMatch.route.action && !actionMatch.route.lazy) {\n let error = getInternalRouterError(405, {\n method: request.method,\n pathname: new URL(request.url).pathname,\n routeId: actionMatch.route.id,\n });\n if (isRouteRequest) {\n throw error;\n }\n result = {\n type: ResultType.error,\n error,\n };\n } else {\n result = await callLoaderOrAction(\n \"action\",\n request,\n actionMatch,\n matches,\n manifest,\n mapRouteProperties,\n basename,\n { isStaticRequest: true, isRouteRequest, requestContext }\n );\n\n if (request.signal.aborted) {\n let method = isRouteRequest ? \"queryRoute\" : \"query\";\n throw new Error(`${method}() call aborted`);\n }\n }\n\n if (isRedirectResult(result)) {\n // Uhhhh - this should never happen, we should always throw these from\n // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n // can get back on the \"throw all redirect responses\" train here should\n // this ever happen :/\n throw new Response(null, {\n status: result.status,\n headers: {\n Location: result.location,\n },\n });\n }\n\n if (isDeferredResult(result)) {\n let error = getInternalRouterError(400, { type: \"defer-action\" });\n if (isRouteRequest) {\n throw error;\n }\n result = {\n type: ResultType.error,\n error,\n };\n }\n\n if (isRouteRequest) {\n // Note: This should only be non-Response values if we get here, since\n // isRouteRequest should throw any Response received in callLoaderOrAction\n if (isErrorResult(result)) {\n throw result.error;\n }\n\n return {\n matches: [actionMatch],\n loaderData: {},\n actionData: { [actionMatch.route.id]: result.data },\n errors: null,\n // Note: statusCode + headers are unused here since queryRoute will\n // return the raw Response or value\n statusCode: 200,\n loaderHeaders: {},\n actionHeaders: {},\n activeDeferreds: null,\n };\n }\n\n if (isErrorResult(result)) {\n // Store off the pending error - we use it to determine which loaders\n // to call and will commit it when we complete the navigation\n let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n let context = await loadRouteData(\n request,\n matches,\n requestContext,\n undefined,\n {\n [boundaryMatch.route.id]: result.error,\n }\n );\n\n // action status codes take precedence over loader status codes\n return {\n ...context,\n statusCode: isRouteErrorResponse(result.error)\n ? result.error.status\n : 500,\n actionData: null,\n actionHeaders: {\n ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n },\n };\n }\n\n // Create a GET request for the loaders\n let loaderRequest = new Request(request.url, {\n headers: request.headers,\n redirect: request.redirect,\n signal: request.signal,\n });\n let context = await loadRouteData(loaderRequest, matches, requestContext);\n\n return {\n ...context,\n // action status codes take precedence over loader status codes\n ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n actionData: {\n [actionMatch.route.id]: result.data,\n },\n actionHeaders: {\n ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n },\n };\n }\n\n async function loadRouteData(\n request: Request,\n matches: AgnosticDataRouteMatch[],\n requestContext: unknown,\n routeMatch?: AgnosticDataRouteMatch,\n pendingActionError?: RouteData\n ): Promise<\n | Omit<\n StaticHandlerContext,\n \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n >\n | Response\n > {\n let isRouteRequest = routeMatch != null;\n\n // Short circuit if we have no loaders to run (queryRoute())\n if (\n isRouteRequest &&\n !routeMatch?.route.loader &&\n !routeMatch?.route.lazy\n ) {\n throw getInternalRouterError(400, {\n method: request.method,\n pathname: new URL(request.url).pathname,\n routeId: routeMatch?.route.id,\n });\n }\n\n let requestMatches = routeMatch\n ? [routeMatch]\n : getLoaderMatchesUntilBoundary(\n matches,\n Object.keys(pendingActionError || {})[0]\n );\n let matchesToLoad = requestMatches.filter(\n (m) => m.route.loader || m.route.lazy\n );\n\n // Short circuit if we have no loaders to run (query())\n if (matchesToLoad.length === 0) {\n return {\n matches,\n // Add a null for all matched routes for proper revalidation on the client\n loaderData: matches.reduce(\n (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n {}\n ),\n errors: pendingActionError || null,\n statusCode: 200,\n loaderHeaders: {},\n activeDeferreds: null,\n };\n }\n\n let results = await Promise.all([\n ...matchesToLoad.map((match) =>\n callLoaderOrAction(\n \"loader\",\n request,\n match,\n matches,\n manifest,\n mapRouteProperties,\n basename,\n { isStaticRequest: true, isRouteRequest, requestContext }\n )\n ),\n ]);\n\n if (request.signal.aborted) {\n let method = isRouteRequest ? \"queryRoute\" : \"query\";\n throw new Error(`${method}() call aborted`);\n }\n\n // Process and commit output from loaders\n let activeDeferreds = new Map();\n let context = processRouteLoaderData(\n matches,\n matchesToLoad,\n results,\n pendingActionError,\n activeDeferreds\n );\n\n // Add a null for any non-loader matches for proper revalidation on the client\n let executedLoaders = new Set(\n matchesToLoad.map((match) => match.route.id)\n );\n matches.forEach((match) => {\n if (!executedLoaders.has(match.route.id)) {\n context.loaderData[match.route.id] = null;\n }\n });\n\n return {\n ...context,\n matches,\n activeDeferreds:\n activeDeferreds.size > 0\n ? Object.fromEntries(activeDeferreds.entries())\n : null,\n };\n }\n\n return {\n dataRoutes,\n query,\n queryRoute,\n };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n routes: AgnosticDataRouteObject[],\n context: StaticHandlerContext,\n error: any\n) {\n let newContext: StaticHandlerContext = {\n ...context,\n statusCode: 500,\n errors: {\n [context._deepestRenderedBoundaryId || routes[0].id]: error,\n },\n };\n return newContext;\n}\n\nfunction isSubmissionNavigation(\n opts: RouterNavigateOptions\n): opts is SubmissionNavigateOptions {\n return (\n opts != null &&\n ((\"formData\" in opts && opts.formData != null) ||\n (\"body\" in opts && opts.body !== undefined))\n );\n}\n\nfunction normalizeTo(\n location: Path,\n matches: AgnosticDataRouteMatch[],\n basename: string,\n prependBasename: boolean,\n to: To | null,\n fromRouteId?: string,\n relative?: RelativeRoutingType\n) {\n let contextualMatches: AgnosticDataRouteMatch[];\n let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n if (fromRouteId != null && relative !== \"path\") {\n // Grab matches up to the calling route so our route-relative logic is\n // relative to the correct source route. When using relative:path,\n // fromRouteId is ignored since that is always relative to the current\n // location path\n contextualMatches = [];\n for (let match of matches) {\n contextualMatches.push(match);\n if (match.route.id === fromRouteId) {\n activeRouteMatch = match;\n break;\n }\n }\n } else {\n contextualMatches = matches;\n activeRouteMatch = matches[matches.length - 1];\n }\n\n // Resolve the relative path\n let path = resolveTo(\n to ? to : \".\",\n getPathContributingMatches(contextualMatches).map((m) => m.pathnameBase),\n stripBasename(location.pathname, basename) || location.pathname,\n relative === \"path\"\n );\n\n // When `to` is not specified we inherit search/hash from the current\n // location, unlike when to=\".\" and we just inherit the path.\n // See https://github.com/remix-run/remix/issues/927\n if (to == null) {\n path.search = location.search;\n path.hash = location.hash;\n }\n\n // Add an ?index param for matched index routes if we don't already have one\n if (\n (to == null || to === \"\" || to === \".\") &&\n activeRouteMatch &&\n activeRouteMatch.route.index &&\n !hasNakedIndexQuery(path.search)\n ) {\n path.search = path.search\n ? path.search.replace(/^\\?/, \"?index&\")\n : \"?index\";\n }\n\n // If we're operating within a basename, prepend it to the pathname. If\n // this is a root navigation, then just use the raw basename which allows\n // the basename to have full control over the presence of a trailing slash\n // on root actions\n if (prependBasename && basename !== \"/\") {\n path.pathname =\n path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n }\n\n return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n normalizeFormMethod: boolean,\n isFetcher: boolean,\n path: string,\n opts?: RouterNavigateOptions\n): {\n path: string;\n submission?: Submission;\n error?: ErrorResponse;\n} {\n // Return location verbatim on non-submission navigations\n if (!opts || !isSubmissionNavigation(opts)) {\n return { path };\n }\n\n if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n return {\n path,\n error: getInternalRouterError(405, { method: opts.formMethod }),\n };\n }\n\n let getInvalidBodyError = () => ({\n path,\n error: getInternalRouterError(400, { type: \"invalid-body\" }),\n });\n\n // Create a Submission on non-GET navigations\n let rawFormMethod = opts.formMethod || \"get\";\n let formMethod = normalizeFormMethod\n ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n : (rawFormMethod.toLowerCase() as FormMethod);\n let formAction = stripHashFromPath(path);\n\n if (opts.body !== undefined) {\n if (opts.formEncType === \"text/plain\") {\n // text only support POST/PUT/PATCH/DELETE submissions\n if (!isMutationMethod(formMethod)) {\n return getInvalidBodyError();\n }\n\n let text =\n typeof opts.body === \"string\"\n ? opts.body\n : opts.body instanceof FormData ||\n opts.body instanceof URLSearchParams\n ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n Array.from(opts.body.entries()).reduce(\n (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n \"\"\n )\n : String(opts.body);\n\n return {\n path,\n submission: {\n formMethod,\n formAction,\n formEncType: opts.formEncType,\n formData: undefined,\n json: undefined,\n text,\n },\n };\n } else if (opts.formEncType === \"application/json\") {\n // json only supports POST/PUT/PATCH/DELETE submissions\n if (!isMutationMethod(formMethod)) {\n return getInvalidBodyError();\n }\n\n try {\n let json =\n typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n return {\n path,\n submission: {\n formMethod,\n formAction,\n formEncType: opts.formEncType,\n formData: undefined,\n json,\n text: undefined,\n },\n };\n } catch (e) {\n return getInvalidBodyError();\n }\n }\n }\n\n invariant(\n typeof FormData === \"function\",\n \"FormData is not available in this environment\"\n );\n\n let searchParams: URLSearchParams;\n let formData: FormData;\n\n if (opts.formData) {\n searchParams = convertFormDataToSearchParams(opts.formData);\n formData = opts.formData;\n } else if (opts.body instanceof FormData) {\n searchParams = convertFormDataToSearchParams(opts.body);\n formData = opts.body;\n } else if (opts.body instanceof URLSearchParams) {\n searchParams = opts.body;\n formData = convertSearchParamsToFormData(searchParams);\n } else if (opts.body == null) {\n searchParams = new URLSearchParams();\n formData = new FormData();\n } else {\n try {\n searchParams = new URLSearchParams(opts.body);\n formData = convertSearchParamsToFormData(searchParams);\n } catch (e) {\n return getInvalidBodyError();\n }\n }\n\n let submission: Submission = {\n formMethod,\n formAction,\n formEncType:\n (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n formData,\n json: undefined,\n text: undefined,\n };\n\n if (isMutationMethod(submission.formMethod)) {\n return { path, submission };\n }\n\n // Flatten submission onto URLSearchParams for GET submissions\n let parsedPath = parsePath(path);\n // On GET navigation submissions we can drop the ?index param from the\n // resulting location since all loaders will run. But fetcher GET submissions\n // only run a single loader so we need to preserve any incoming ?index params\n if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n searchParams.append(\"index\", \"\");\n }\n parsedPath.search = `?${searchParams}`;\n\n return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n matches: AgnosticDataRouteMatch[],\n boundaryId?: string\n) {\n let boundaryMatches = matches;\n if (boundaryId) {\n let index = matches.findIndex((m) => m.route.id === boundaryId);\n if (index >= 0) {\n boundaryMatches = matches.slice(0, index);\n }\n }\n return boundaryMatches;\n}\n\nfunction getMatchesToLoad(\n history: History,\n state: RouterState,\n matches: AgnosticDataRouteMatch[],\n submission: Submission | undefined,\n location: Location,\n isRevalidationRequired: boolean,\n cancelledDeferredRoutes: string[],\n cancelledFetcherLoads: string[],\n fetchLoadMatches: Map,\n fetchRedirectIds: Set,\n routesToUse: AgnosticDataRouteObject[],\n basename: string | undefined,\n pendingActionData?: RouteData,\n pendingError?: RouteData\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n let actionResult = pendingError\n ? Object.values(pendingError)[0]\n : pendingActionData\n ? Object.values(pendingActionData)[0]\n : undefined;\n\n let currentUrl = history.createURL(state.location);\n let nextUrl = history.createURL(location);\n\n // Pick navigation matches that are net-new or qualify for revalidation\n let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n\n let navigationMatches = boundaryMatches.filter((match, index) => {\n if (match.route.lazy) {\n // We haven't loaded this route yet so we don't know if it's got a loader!\n return true;\n }\n if (match.route.loader == null) {\n return false;\n }\n\n // Always call the loader on new route instances and pending defer cancellations\n if (\n isNewLoader(state.loaderData, state.matches[index], match) ||\n cancelledDeferredRoutes.some((id) => id === match.route.id)\n ) {\n return true;\n }\n\n // This is the default implementation for when we revalidate. If the route\n // provides it's own implementation, then we give them full control but\n // provide this value so they can leverage it if needed after they check\n // their own specific use cases\n let currentRouteMatch = state.matches[index];\n let nextRouteMatch = match;\n\n return shouldRevalidateLoader(match, {\n currentUrl,\n currentParams: currentRouteMatch.params,\n nextUrl,\n nextParams: nextRouteMatch.params,\n ...submission,\n actionResult,\n defaultShouldRevalidate:\n // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n isRevalidationRequired ||\n // Clicked the same link, resubmitted a GET form\n currentUrl.pathname + currentUrl.search ===\n nextUrl.pathname + nextUrl.search ||\n // Search params affect all loaders\n currentUrl.search !== nextUrl.search ||\n isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n });\n });\n\n // Pick fetcher.loads that need to be revalidated\n let revalidatingFetchers: RevalidatingFetcher[] = [];\n fetchLoadMatches.forEach((f, key) => {\n // Don't revalidate if fetcher won't be present in the subsequent render\n if (!matches.some((m) => m.route.id === f.routeId)) {\n return;\n }\n\n let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n // If the fetcher path no longer matches, push it in with null matches so\n // we can trigger a 404 in callLoadersAndMaybeResolveData. Note this is\n // currently only a use-case for Remix HMR where the route tree can change\n // at runtime and remove a route previously loaded via a fetcher\n if (!fetcherMatches) {\n revalidatingFetchers.push({\n key,\n routeId: f.routeId,\n path: f.path,\n matches: null,\n match: null,\n controller: null,\n });\n return;\n }\n\n // Revalidating fetchers are decoupled from the route matches since they\n // load from a static href. They revalidate based on explicit revalidation\n // (submission, useRevalidator, or X-Remix-Revalidate)\n let fetcher = state.fetchers.get(key);\n let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n let shouldRevalidate = false;\n if (fetchRedirectIds.has(key)) {\n // Never trigger a revalidation of an actively redirecting fetcher\n shouldRevalidate = false;\n } else if (cancelledFetcherLoads.includes(key)) {\n // Always revalidate if the fetcher was cancelled\n shouldRevalidate = true;\n } else if (\n fetcher &&\n fetcher.state !== \"idle\" &&\n fetcher.data === undefined\n ) {\n // If the fetcher hasn't ever completed loading yet, then this isn't a\n // revalidation, it would just be a brand new load if an explicit\n // revalidation is required\n shouldRevalidate = isRevalidationRequired;\n } else {\n // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n // to explicit revalidations only\n shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n currentUrl,\n currentParams: state.matches[state.matches.length - 1].params,\n nextUrl,\n nextParams: matches[matches.length - 1].params,\n ...submission,\n actionResult,\n defaultShouldRevalidate: isRevalidationRequired,\n });\n }\n\n if (shouldRevalidate) {\n revalidatingFetchers.push({\n key,\n routeId: f.routeId,\n path: f.path,\n matches: fetcherMatches,\n match: fetcherMatch,\n controller: new AbortController(),\n });\n }\n });\n\n return [navigationMatches, revalidatingFetchers];\n}\n\nfunction isNewLoader(\n currentLoaderData: RouteData,\n currentMatch: AgnosticDataRouteMatch,\n match: AgnosticDataRouteMatch\n) {\n let isNew =\n // [a] -> [a, b]\n !currentMatch ||\n // [a, b] -> [a, c]\n match.route.id !== currentMatch.route.id;\n\n // Handle the case that we don't have data for a re-used route, potentially\n // from a prior error or from a cancelled pending deferred\n let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n // Always load if this is a net-new route or we don't yet have data\n return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n currentMatch: AgnosticDataRouteMatch,\n match: AgnosticDataRouteMatch\n) {\n let currentPath = currentMatch.route.path;\n return (\n // param change for this match, /users/123 -> /users/456\n currentMatch.pathname !== match.pathname ||\n // splat param changed, which is not present in match.path\n // e.g. /files/images/avatar.jpg -> files/finances.xls\n (currentPath != null &&\n currentPath.endsWith(\"*\") &&\n currentMatch.params[\"*\"] !== match.params[\"*\"])\n );\n}\n\nfunction shouldRevalidateLoader(\n loaderMatch: AgnosticDataRouteMatch,\n arg: Parameters[0]\n) {\n if (loaderMatch.route.shouldRevalidate) {\n let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n if (typeof routeChoice === \"boolean\") {\n return routeChoice;\n }\n }\n\n return arg.defaultShouldRevalidate;\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n route: AgnosticDataRouteObject,\n mapRouteProperties: MapRoutePropertiesFunction,\n manifest: RouteManifest\n) {\n if (!route.lazy) {\n return;\n }\n\n let lazyRoute = await route.lazy();\n\n // If the lazy route function was executed and removed by another parallel\n // call then we can return - first lazy() to finish wins because the return\n // value of lazy is expected to be static\n if (!route.lazy) {\n return;\n }\n\n let routeToUpdate = manifest[route.id];\n invariant(routeToUpdate, \"No route found in manifest\");\n\n // Update the route in place. This should be safe because there's no way\n // we could yet be sitting on this route as we can't get there without\n // resolving lazy() first.\n //\n // This is different than the HMR \"update\" use-case where we may actively be\n // on the route being updated. The main concern boils down to \"does this\n // mutation affect any ongoing navigations or any current state.matches\n // values?\". If not, it should be safe to update in place.\n let routeUpdates: Record = {};\n for (let lazyRouteProperty in lazyRoute) {\n let staticRouteValue =\n routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n let isPropertyStaticallyDefined =\n staticRouteValue !== undefined &&\n // This property isn't static since it should always be updated based\n // on the route updates\n lazyRouteProperty !== \"hasErrorBoundary\";\n\n warning(\n !isPropertyStaticallyDefined,\n `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n `defined but its lazy function is also returning a value for this property. ` +\n `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n );\n\n if (\n !isPropertyStaticallyDefined &&\n !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n ) {\n routeUpdates[lazyRouteProperty] =\n lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n }\n }\n\n // Mutate the route with the provided updates. Do this first so we pass\n // the updated version to mapRouteProperties\n Object.assign(routeToUpdate, routeUpdates);\n\n // Mutate the `hasErrorBoundary` property on the route based on the route\n // updates and remove the `lazy` function so we don't resolve the lazy\n // route again.\n Object.assign(routeToUpdate, {\n // To keep things framework agnostic, we use the provided\n // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n // the logic will differ between frameworks.\n ...mapRouteProperties(routeToUpdate),\n lazy: undefined,\n });\n}\n\nasync function callLoaderOrAction(\n type: \"loader\" | \"action\",\n request: Request,\n match: AgnosticDataRouteMatch,\n matches: AgnosticDataRouteMatch[],\n manifest: RouteManifest,\n mapRouteProperties: MapRoutePropertiesFunction,\n basename: string,\n opts: {\n isStaticRequest?: boolean;\n isRouteRequest?: boolean;\n requestContext?: unknown;\n } = {}\n): Promise {\n let resultType;\n let result;\n let onReject: (() => void) | undefined;\n\n let runHandler = (handler: ActionFunction | LoaderFunction) => {\n // Setup a promise we can race against so that abort signals short circuit\n let reject: () => void;\n let abortPromise = new Promise((_, r) => (reject = r));\n onReject = () => reject();\n request.signal.addEventListener(\"abort\", onReject);\n return Promise.race([\n handler({\n request,\n params: match.params,\n context: opts.requestContext,\n }),\n abortPromise,\n ]);\n };\n\n try {\n let handler = match.route[type];\n\n if (match.route.lazy) {\n if (handler) {\n // Run statically defined handler in parallel with lazy()\n let values = await Promise.all([\n runHandler(handler),\n loadLazyRouteModule(match.route, mapRouteProperties, manifest),\n ]);\n result = values[0];\n } else {\n // Load lazy route module, then run any returned handler\n await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n\n handler = match.route[type];\n if (handler) {\n // Handler still run even if we got interrupted to maintain consistency\n // with un-abortable behavior of handler execution on non-lazy or\n // previously-lazy-loaded routes\n result = await runHandler(handler);\n } else if (type === \"action\") {\n let url = new URL(request.url);\n let pathname = url.pathname + url.search;\n throw getInternalRouterError(405, {\n method: request.method,\n pathname,\n routeId: match.route.id,\n });\n } else {\n // lazy() route has no loader to run. Short circuit here so we don't\n // hit the invariant below that errors on returning undefined.\n return { type: ResultType.data, data: undefined };\n }\n }\n } else if (!handler) {\n let url = new URL(request.url);\n let pathname = url.pathname + url.search;\n throw getInternalRouterError(404, {\n pathname,\n });\n } else {\n result = await runHandler(handler);\n }\n\n invariant(\n result !== undefined,\n `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n `function. Please return a value or \\`null\\`.`\n );\n } catch (e) {\n resultType = ResultType.error;\n result = e;\n } finally {\n if (onReject) {\n request.signal.removeEventListener(\"abort\", onReject);\n }\n }\n\n if (isResponse(result)) {\n let status = result.status;\n\n // Process redirects\n if (redirectStatusCodes.has(status)) {\n let location = result.headers.get(\"Location\");\n invariant(\n location,\n \"Redirects returned/thrown from loaders/actions must have a Location header\"\n );\n\n // Support relative routing in internal redirects\n if (!ABSOLUTE_URL_REGEX.test(location)) {\n location = normalizeTo(\n new URL(request.url),\n matches.slice(0, matches.indexOf(match) + 1),\n basename,\n true,\n location\n );\n } else if (!opts.isStaticRequest) {\n // Strip off the protocol+origin for same-origin + same-basename absolute\n // redirects. If this is a static request, we can let it go back to the\n // browser as-is\n let currentUrl = new URL(request.url);\n let url = location.startsWith(\"//\")\n ? new URL(currentUrl.protocol + location)\n : new URL(location);\n let isSameBasename = stripBasename(url.pathname, basename) != null;\n if (url.origin === currentUrl.origin && isSameBasename) {\n location = url.pathname + url.search + url.hash;\n }\n }\n\n // Don't process redirects in the router during static requests requests.\n // Instead, throw the Response and let the server handle it with an HTTP\n // redirect. We also update the Location header in place in this flow so\n // basename and relative routing is taken into account\n if (opts.isStaticRequest) {\n result.headers.set(\"Location\", location);\n throw result;\n }\n\n return {\n type: ResultType.redirect,\n status,\n location,\n revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null,\n };\n }\n\n // For SSR single-route requests, we want to hand Responses back directly\n // without unwrapping. We do this with the QueryRouteResponse wrapper\n // interface so we can know whether it was returned or thrown\n if (opts.isRouteRequest) {\n // eslint-disable-next-line no-throw-literal\n throw {\n type: resultType || ResultType.data,\n response: result,\n };\n }\n\n let data: any;\n let contentType = result.headers.get(\"Content-Type\");\n // Check between word boundaries instead of startsWith() due to the last\n // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n data = await result.json();\n } else {\n data = await result.text();\n }\n\n if (resultType === ResultType.error) {\n return {\n type: resultType,\n error: new ErrorResponse(status, result.statusText, data),\n headers: result.headers,\n };\n }\n\n return {\n type: ResultType.data,\n data,\n statusCode: result.status,\n headers: result.headers,\n };\n }\n\n if (resultType === ResultType.error) {\n return { type: resultType, error: result };\n }\n\n if (isDeferredData(result)) {\n return {\n type: ResultType.deferred,\n deferredData: result,\n statusCode: result.init?.status,\n headers: result.init?.headers && new Headers(result.init.headers),\n };\n }\n\n return { type: ResultType.data, data: result };\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches. During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n history: History,\n location: string | Location,\n signal: AbortSignal,\n submission?: Submission\n): Request {\n let url = history.createURL(stripHashFromPath(location)).toString();\n let init: RequestInit = { signal };\n\n if (submission && isMutationMethod(submission.formMethod)) {\n let { formMethod, formEncType } = submission;\n // Didn't think we needed this but it turns out unlike other methods, patch\n // won't be properly normalized to uppercase and results in a 405 error.\n // See: https://fetch.spec.whatwg.org/#concept-method\n init.method = formMethod.toUpperCase();\n\n if (formEncType === \"application/json\") {\n init.headers = new Headers({ \"Content-Type\": formEncType });\n init.body = JSON.stringify(submission.json);\n } else if (formEncType === \"text/plain\") {\n // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n init.body = submission.text;\n } else if (\n formEncType === \"application/x-www-form-urlencoded\" &&\n submission.formData\n ) {\n // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n init.body = convertFormDataToSearchParams(submission.formData);\n } else {\n // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n init.body = submission.formData;\n }\n }\n\n return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n let searchParams = new URLSearchParams();\n\n for (let [key, value] of formData.entries()) {\n // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n searchParams.append(key, typeof value === \"string\" ? value : value.name);\n }\n\n return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n searchParams: URLSearchParams\n): FormData {\n let formData = new FormData();\n for (let [key, value] of searchParams.entries()) {\n formData.append(key, value);\n }\n return formData;\n}\n\nfunction processRouteLoaderData(\n matches: AgnosticDataRouteMatch[],\n matchesToLoad: AgnosticDataRouteMatch[],\n results: DataResult[],\n pendingError: RouteData | undefined,\n activeDeferreds: Map\n): {\n loaderData: RouterState[\"loaderData\"];\n errors: RouterState[\"errors\"] | null;\n statusCode: number;\n loaderHeaders: Record;\n} {\n // Fill in loaderData/errors from our loaders\n let loaderData: RouterState[\"loaderData\"] = {};\n let errors: RouterState[\"errors\"] | null = null;\n let statusCode: number | undefined;\n let foundError = false;\n let loaderHeaders: Record = {};\n\n // Process loader results into state.loaderData/state.errors\n results.forEach((result, index) => {\n let id = matchesToLoad[index].route.id;\n invariant(\n !isRedirectResult(result),\n \"Cannot handle redirect results in processLoaderData\"\n );\n if (isErrorResult(result)) {\n // Look upwards from the matched route for the closest ancestor\n // error boundary, defaulting to the root match\n let boundaryMatch = findNearestBoundary(matches, id);\n let error = result.error;\n // If we have a pending action error, we report it at the highest-route\n // that throws a loader error, and then clear it out to indicate that\n // it was consumed\n if (pendingError) {\n error = Object.values(pendingError)[0];\n pendingError = undefined;\n }\n\n errors = errors || {};\n\n // Prefer higher error values if lower errors bubble to the same boundary\n if (errors[boundaryMatch.route.id] == null) {\n errors[boundaryMatch.route.id] = error;\n }\n\n // Clear our any prior loaderData for the throwing route\n loaderData[id] = undefined;\n\n // Once we find our first (highest) error, we set the status code and\n // prevent deeper status codes from overriding\n if (!foundError) {\n foundError = true;\n statusCode = isRouteErrorResponse(result.error)\n ? result.error.status\n : 500;\n }\n if (result.headers) {\n loaderHeaders[id] = result.headers;\n }\n } else {\n if (isDeferredResult(result)) {\n activeDeferreds.set(id, result.deferredData);\n loaderData[id] = result.deferredData.data;\n } else {\n loaderData[id] = result.data;\n }\n\n // Error status codes always override success status codes, but if all\n // loaders are successful we take the deepest status code.\n if (\n result.statusCode != null &&\n result.statusCode !== 200 &&\n !foundError\n ) {\n statusCode = result.statusCode;\n }\n if (result.headers) {\n loaderHeaders[id] = result.headers;\n }\n }\n });\n\n // If we didn't consume the pending action error (i.e., all loaders\n // resolved), then consume it here. Also clear out any loaderData for the\n // throwing route\n if (pendingError) {\n errors = pendingError;\n loaderData[Object.keys(pendingError)[0]] = undefined;\n }\n\n return {\n loaderData,\n errors,\n statusCode: statusCode || 200,\n loaderHeaders,\n };\n}\n\nfunction processLoaderData(\n state: RouterState,\n matches: AgnosticDataRouteMatch[],\n matchesToLoad: AgnosticDataRouteMatch[],\n results: DataResult[],\n pendingError: RouteData | undefined,\n revalidatingFetchers: RevalidatingFetcher[],\n fetcherResults: DataResult[],\n activeDeferreds: Map\n): {\n loaderData: RouterState[\"loaderData\"];\n errors?: RouterState[\"errors\"];\n} {\n let { loaderData, errors } = processRouteLoaderData(\n matches,\n matchesToLoad,\n results,\n pendingError,\n activeDeferreds\n );\n\n // Process results from our revalidating fetchers\n for (let index = 0; index < revalidatingFetchers.length; index++) {\n let { key, match, controller } = revalidatingFetchers[index];\n invariant(\n fetcherResults !== undefined && fetcherResults[index] !== undefined,\n \"Did not find corresponding fetcher result\"\n );\n let result = fetcherResults[index];\n\n // Process fetcher non-redirect errors\n if (controller && controller.signal.aborted) {\n // Nothing to do for aborted fetchers\n continue;\n } else if (isErrorResult(result)) {\n let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n if (!(errors && errors[boundaryMatch.route.id])) {\n errors = {\n ...errors,\n [boundaryMatch.route.id]: result.error,\n };\n }\n state.fetchers.delete(key);\n } else if (isRedirectResult(result)) {\n // Should never get here, redirects should get processed above, but we\n // keep this to type narrow to a success result in the else\n invariant(false, \"Unhandled fetcher revalidation redirect\");\n } else if (isDeferredResult(result)) {\n // Should never get here, deferred data should be awaited for fetchers\n // in resolveDeferredResults\n invariant(false, \"Unhandled fetcher deferred data\");\n } else {\n let doneFetcher = getDoneFetcher(result.data);\n state.fetchers.set(key, doneFetcher);\n }\n }\n\n return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n loaderData: RouteData,\n newLoaderData: RouteData,\n matches: AgnosticDataRouteMatch[],\n errors: RouteData | null | undefined\n): RouteData {\n let mergedLoaderData = { ...newLoaderData };\n for (let match of matches) {\n let id = match.route.id;\n if (newLoaderData.hasOwnProperty(id)) {\n if (newLoaderData[id] !== undefined) {\n mergedLoaderData[id] = newLoaderData[id];\n } else {\n // No-op - this is so we ignore existing data if we have a key in the\n // incoming object with an undefined value, which is how we unset a prior\n // loaderData if we encounter a loader error\n }\n } else if (loaderData[id] !== undefined && match.route.loader) {\n // Preserve existing keys not included in newLoaderData and where a loader\n // wasn't removed by HMR\n mergedLoaderData[id] = loaderData[id];\n }\n\n if (errors && errors.hasOwnProperty(id)) {\n // Don't keep any loader data below the boundary\n break;\n }\n }\n return mergedLoaderData;\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n matches: AgnosticDataRouteMatch[],\n routeId?: string\n): AgnosticDataRouteMatch {\n let eligibleMatches = routeId\n ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n : [...matches];\n return (\n eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n matches[0]\n );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n matches: AgnosticDataRouteMatch[];\n route: AgnosticDataRouteObject;\n} {\n // Prefer a root layout route if present, otherwise shim in a route object\n let route = routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n id: `__shim-error-route__`,\n };\n\n return {\n matches: [\n {\n params: {},\n pathname: \"\",\n pathnameBase: \"\",\n route,\n },\n ],\n route,\n };\n}\n\nfunction getInternalRouterError(\n status: number,\n {\n pathname,\n routeId,\n method,\n type,\n }: {\n pathname?: string;\n routeId?: string;\n method?: string;\n type?: \"defer-action\" | \"invalid-body\";\n } = {}\n) {\n let statusText = \"Unknown Server Error\";\n let errorMessage = \"Unknown @remix-run/router error\";\n\n if (status === 400) {\n statusText = \"Bad Request\";\n if (method && pathname && routeId) {\n errorMessage =\n `You made a ${method} request to \"${pathname}\" but ` +\n `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n `so there is no way to handle the request.`;\n } else if (type === \"defer-action\") {\n errorMessage = \"defer() is not supported in actions\";\n } else if (type === \"invalid-body\") {\n errorMessage = \"Unable to encode submission body\";\n }\n } else if (status === 403) {\n statusText = \"Forbidden\";\n errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n } else if (status === 404) {\n statusText = \"Not Found\";\n errorMessage = `No route matches URL \"${pathname}\"`;\n } else if (status === 405) {\n statusText = \"Method Not Allowed\";\n if (method && pathname && routeId) {\n errorMessage =\n `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n `did not provide an \\`action\\` for route \"${routeId}\", ` +\n `so there is no way to handle the request.`;\n } else if (method) {\n errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n }\n }\n\n return new ErrorResponse(\n status || 500,\n statusText,\n new Error(errorMessage),\n true\n );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n results: DataResult[]\n): { result: RedirectResult; idx: number } | undefined {\n for (let i = results.length - 1; i >= 0; i--) {\n let result = results[i];\n if (isRedirectResult(result)) {\n return { result, idx: i };\n }\n }\n}\n\nfunction stripHashFromPath(path: To) {\n let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n if (a.pathname !== b.pathname || a.search !== b.search) {\n return false;\n }\n\n if (a.hash === \"\") {\n // /page -> /page#hash\n return b.hash !== \"\";\n } else if (a.hash === b.hash) {\n // /page#hash -> /page#hash\n return true;\n } else if (b.hash !== \"\") {\n // /page#hash -> /page#other\n return true;\n }\n\n // If the hash is removed the browser will re-perform a request to the server\n // /page#hash -> /page\n return false;\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n let deferred: DeferredData = value;\n return (\n deferred &&\n typeof deferred === \"object\" &&\n typeof deferred.data === \"object\" &&\n typeof deferred.subscribe === \"function\" &&\n typeof deferred.cancel === \"function\" &&\n typeof deferred.resolveData === \"function\"\n );\n}\n\nfunction isResponse(value: any): value is Response {\n return (\n value != null &&\n typeof value.status === \"number\" &&\n typeof value.statusText === \"string\" &&\n typeof value.headers === \"object\" &&\n typeof value.body !== \"undefined\"\n );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n if (!isResponse(result)) {\n return false;\n }\n\n let status = result.status;\n let location = result.headers.get(\"Location\");\n return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isQueryRouteResponse(obj: any): obj is QueryRouteResponse {\n return (\n obj &&\n isResponse(obj.response) &&\n (obj.type === ResultType.data || ResultType.error)\n );\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveDeferredResults(\n currentMatches: AgnosticDataRouteMatch[],\n matchesToLoad: (AgnosticDataRouteMatch | null)[],\n results: DataResult[],\n signals: (AbortSignal | null)[],\n isFetcher: boolean,\n currentLoaderData?: RouteData\n) {\n for (let index = 0; index < results.length; index++) {\n let result = results[index];\n let match = matchesToLoad[index];\n // If we don't have a match, then we can have a deferred result to do\n // anything with. This is for revalidating fetchers where the route was\n // removed during HMR\n if (!match) {\n continue;\n }\n\n let currentMatch = currentMatches.find(\n (m) => m.route.id === match!.route.id\n );\n let isRevalidatingLoader =\n currentMatch != null &&\n !isNewRouteInstance(currentMatch, match) &&\n (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n // Note: we do not have to touch activeDeferreds here since we race them\n // against the signal in resolveDeferredData and they'll get aborted\n // there if needed\n let signal = signals[index];\n invariant(\n signal,\n \"Expected an AbortSignal for revalidating fetcher deferred result\"\n );\n await resolveDeferredData(result, signal, isFetcher).then((result) => {\n if (result) {\n results[index] = result || results[index];\n }\n });\n }\n }\n}\n\nasync function resolveDeferredData(\n result: DeferredResult,\n signal: AbortSignal,\n unwrap = false\n): Promise {\n let aborted = await result.deferredData.resolveData(signal);\n if (aborted) {\n return;\n }\n\n if (unwrap) {\n try {\n return {\n type: ResultType.data,\n data: result.deferredData.unwrappedData,\n };\n } catch (e) {\n // Handle any TrackedPromise._error values encountered while unwrapping\n return {\n type: ResultType.error,\n error: e,\n };\n }\n }\n\n return {\n type: ResultType.data,\n data: result.deferredData.data,\n };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\n// Note: This should match the format exported by useMatches, so if you change\n// this please also change that :) Eventually we'll DRY this up\nfunction createUseMatchesMatch(\n match: AgnosticDataRouteMatch,\n loaderData: RouteData\n): UseMatchesMatch {\n let { route, pathname, params } = match;\n return {\n id: route.id,\n pathname,\n params,\n data: loaderData[route.id] as unknown,\n handle: route.handle as unknown,\n };\n}\n\nfunction getTargetMatch(\n matches: AgnosticDataRouteMatch[],\n location: Location | string\n) {\n let search =\n typeof location === \"string\" ? parsePath(location).search : location.search;\n if (\n matches[matches.length - 1].route.index &&\n hasNakedIndexQuery(search || \"\")\n ) {\n // Return the leaf index route when index is present\n return matches[matches.length - 1];\n }\n // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n // pathless layout routes)\n let pathMatches = getPathContributingMatches(matches);\n return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n navigation: Navigation\n): Submission | undefined {\n let { formMethod, formAction, formEncType, text, formData, json } =\n navigation;\n if (!formMethod || !formAction || !formEncType) {\n return;\n }\n\n if (text != null) {\n return {\n formMethod,\n formAction,\n formEncType,\n formData: undefined,\n json: undefined,\n text,\n };\n } else if (formData != null) {\n return {\n formMethod,\n formAction,\n formEncType,\n formData,\n json: undefined,\n text: undefined,\n };\n } else if (json !== undefined) {\n return {\n formMethod,\n formAction,\n formEncType,\n formData: undefined,\n json,\n text: undefined,\n };\n }\n}\n\nfunction getLoadingNavigation(\n location: Location,\n submission?: Submission\n): NavigationStates[\"Loading\"] {\n if (submission) {\n let navigation: NavigationStates[\"Loading\"] = {\n state: \"loading\",\n location,\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n };\n return navigation;\n } else {\n let navigation: NavigationStates[\"Loading\"] = {\n state: \"loading\",\n location,\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n };\n return navigation;\n }\n}\n\nfunction getSubmittingNavigation(\n location: Location,\n submission: Submission\n): NavigationStates[\"Submitting\"] {\n let navigation: NavigationStates[\"Submitting\"] = {\n state: \"submitting\",\n location,\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n };\n return navigation;\n}\n\nfunction getLoadingFetcher(\n submission?: Submission,\n data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n if (submission) {\n let fetcher: FetcherStates[\"Loading\"] = {\n state: \"loading\",\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n data,\n \" _hasFetcherDoneAnything \": true,\n };\n return fetcher;\n } else {\n let fetcher: FetcherStates[\"Loading\"] = {\n state: \"loading\",\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n data,\n \" _hasFetcherDoneAnything \": true,\n };\n return fetcher;\n }\n}\n\nfunction getSubmittingFetcher(\n submission: Submission,\n existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n let fetcher: FetcherStates[\"Submitting\"] = {\n state: \"submitting\",\n formMethod: submission.formMethod,\n formAction: submission.formAction,\n formEncType: submission.formEncType,\n formData: submission.formData,\n json: submission.json,\n text: submission.text,\n data: existingFetcher ? existingFetcher.data : undefined,\n \" _hasFetcherDoneAnything \": true,\n };\n return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n let fetcher: FetcherStates[\"Idle\"] = {\n state: \"idle\",\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n data,\n \" _hasFetcherDoneAnything \": true,\n };\n return fetcher;\n}\n//#endregion\n","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n exports.createRoot = m.createRoot;\n exports.hydrateRoot = m.hydrateRoot;\n} else {\n var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n exports.createRoot = function(c, o) {\n i.usingClientEntryPoint = true;\n try {\n return m.createRoot(c, o);\n } finally {\n i.usingClientEntryPoint = false;\n }\n };\n exports.hydrateRoot = function(c, h, o) {\n i.usingClientEntryPoint = true;\n try {\n return m.hydrateRoot(c, h, o);\n } finally {\n i.usingClientEntryPoint = false;\n }\n };\n}\n","import * as React from \"react\";\nimport type {\n AgnosticRouteMatch,\n AgnosticIndexRouteObject,\n AgnosticNonIndexRouteObject,\n History,\n Location,\n RelativeRoutingType,\n Router,\n StaticHandlerContext,\n To,\n TrackedPromise,\n LazyRouteFunction,\n} from \"@remix-run/router\";\nimport type { Action as NavigationType } from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n path?: AgnosticIndexRouteObject[\"path\"];\n id?: AgnosticIndexRouteObject[\"id\"];\n loader?: AgnosticIndexRouteObject[\"loader\"];\n action?: AgnosticIndexRouteObject[\"action\"];\n hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n handle?: AgnosticIndexRouteObject[\"handle\"];\n index: true;\n children?: undefined;\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n lazy?: LazyRouteFunction;\n}\n\nexport interface NonIndexRouteObject {\n caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n path?: AgnosticNonIndexRouteObject[\"path\"];\n id?: AgnosticNonIndexRouteObject[\"id\"];\n loader?: AgnosticNonIndexRouteObject[\"loader\"];\n action?: AgnosticNonIndexRouteObject[\"action\"];\n hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n handle?: AgnosticNonIndexRouteObject[\"handle\"];\n index?: false;\n children?: RouteObject[];\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n lazy?: LazyRouteFunction;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n children?: DataRouteObject[];\n id: string;\n};\n\nexport interface RouteMatch<\n ParamKey extends string = string,\n RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch {}\n\nexport interface DataRouteMatch extends RouteMatch {}\n\nexport interface DataRouterContextObject extends NavigationContextObject {\n router: Router;\n staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n React.createContext(null);\nif (__DEV__) {\n DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext(null);\nif (__DEV__) {\n AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n replace?: boolean;\n state?: any;\n preventScrollReset?: boolean;\n relative?: RelativeRoutingType;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n createHref: History[\"createHref\"];\n // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n encodeLocation?: History[\"encodeLocation\"];\n go: History[\"go\"];\n push(to: To, state?: any, opts?: NavigateOptions): void;\n replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n basename: string;\n navigator: Navigator;\n static: boolean;\n}\n\nexport const NavigationContext = React.createContext(\n null!\n);\n\nif (__DEV__) {\n NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n location: Location;\n navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext(\n null!\n);\n\nif (__DEV__) {\n LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n outlet: React.ReactElement | null;\n matches: RouteMatch[];\n isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext({\n outlet: null,\n matches: [],\n isDataRoute: false,\n});\n\nif (__DEV__) {\n RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext(null);\n\nif (__DEV__) {\n RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n Blocker,\n BlockerFunction,\n Location,\n ParamParseKey,\n Params,\n Path,\n PathMatch,\n PathPattern,\n RelativeRoutingType,\n Router as RemixRouter,\n RevalidationState,\n To,\n} from \"@remix-run/router\";\nimport {\n Action as NavigationType,\n UNSAFE_invariant as invariant,\n isRouteErrorResponse,\n joinPaths,\n matchPath,\n matchRoutes,\n parsePath,\n resolveTo,\n stripBasename,\n IDLE_BLOCKER,\n UNSAFE_getPathContributingMatches as getPathContributingMatches,\n UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n NavigateOptions,\n RouteContextObject,\n RouteMatch,\n RouteObject,\n DataRouteMatch,\n} from \"./context\";\nimport {\n DataRouterContext,\n DataRouterStateContext,\n LocationContext,\n NavigationContext,\n RouteContext,\n RouteErrorContext,\n AwaitContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nexport function useHref(\n to: To,\n { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useHref() may be used only in the context of a component.`\n );\n\n let { basename, navigator } = React.useContext(NavigationContext);\n let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n let joinedPathname = pathname;\n\n // If we're operating within a basename, prepend it to the pathname prior\n // to creating the href. If this is a root navigation, then just use the raw\n // basename which allows the basename to have full control over the presence\n // of a trailing slash on root links\n if (basename !== \"/\") {\n joinedPathname =\n pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n }\n\n return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a .\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nexport function useLocation(): Location {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useLocation() may be used only in the context of a component.`\n );\n\n return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * .\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nexport function useMatch<\n ParamKey extends ParamParseKey,\n Path extends string\n>(pattern: PathPattern | Path): PathMatch | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useMatch() may be used only in the context of a component.`\n );\n\n let { pathname } = useLocation();\n return React.useMemo(\n () => matchPath(pattern, pathname),\n [pathname, pattern]\n );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n (to: To, options?: NavigateOptions): void;\n (delta: number): void;\n}\n\nconst navigateEffectWarning =\n `You should call navigate() in a React.useEffect(), not when ` +\n `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n cb: Parameters[0]\n) {\n let isStatic = React.useContext(NavigationContext).static;\n if (!isStatic) {\n // We should be able to get rid of this once react 18.3 is released\n // See: https://github.com/facebook/react/pull/26395\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useLayoutEffect(cb);\n }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n let { isDataRoute } = React.useContext(RouteContext);\n // Conditional usage is OK here because the usage of a data router is static\n // eslint-disable-next-line react-hooks/rules-of-hooks\n return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useNavigate() may be used only in the context of a component.`\n );\n\n let dataRouterContext = React.useContext(DataRouterContext);\n let { basename, navigator } = React.useContext(NavigationContext);\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n getPathContributingMatches(matches).map((match) => match.pathnameBase)\n );\n\n let activeRef = React.useRef(false);\n useIsomorphicLayoutEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(activeRef.current, navigateEffectWarning);\n\n // Short circuit here since if this happens on first render the navigate\n // is useless because we haven't wired up our history listener yet\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n navigator.go(to);\n return;\n }\n\n let path = resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname,\n options.relative === \"path\"\n );\n\n // If we're operating within a basename, prepend it to the pathname prior\n // to handing off to history (but only if we're not in a data router,\n // otherwise it'll prepend the basename inside of the router).\n // If this is a root navigation, then we navigate to the raw basename\n // which allows the basename to have full control over the presence of a\n // trailing slash on root links\n if (dataRouterContext == null && basename !== \"/\") {\n path.pathname =\n path.pathname === \"/\"\n ? basename\n : joinPaths([basename, path.pathname]);\n }\n\n (!!options.replace ? navigator.replace : navigator.push)(\n path,\n options.state,\n options\n );\n },\n [\n basename,\n navigator,\n routePathnamesJson,\n locationPathname,\n dataRouterContext,\n ]\n );\n\n return navigate;\n}\n\nconst OutletContext = React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nexport function useOutletContext(): Context {\n return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n let outlet = React.useContext(RouteContext).outlet;\n if (outlet) {\n return (\n {outlet}\n );\n }\n return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nexport function useParams<\n ParamsOrKey extends string | Record = string\n>(): Readonly<\n [ParamsOrKey] extends [string] ? Params : Partial\n> {\n let { matches } = React.useContext(RouteContext);\n let routeMatch = matches[matches.length - 1];\n return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n to: To,\n { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n getPathContributingMatches(matches).map((match) => match.pathnameBase)\n );\n\n return React.useMemo(\n () =>\n resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname,\n relative === \"path\"\n ),\n [to, routePathnamesJson, locationPathname, relative]\n );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nexport function useRoutes(\n routes: RouteObject[],\n locationArg?: Partial | string\n): React.ReactElement | null {\n return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n routes: RouteObject[],\n locationArg?: Partial | string,\n dataRouterState?: RemixRouter[\"state\"]\n): React.ReactElement | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useRoutes() may be used only in the context of a component.`\n );\n\n let { navigator } = React.useContext(NavigationContext);\n let { matches: parentMatches } = React.useContext(RouteContext);\n let routeMatch = parentMatches[parentMatches.length - 1];\n let parentParams = routeMatch ? routeMatch.params : {};\n let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n let parentRoute = routeMatch && routeMatch.route;\n\n if (__DEV__) {\n // You won't get a warning about 2 different under a \n // without a trailing *, but this is a best-effort warning anyway since we\n // cannot even give the warning unless they land at the parent route.\n //\n // Example:\n //\n // \n // {/* This route path MUST end with /* because otherwise\n // it will never match /blog/post/123 */}\n // } />\n // } />\n // \n //\n // function Blog() {\n // return (\n // \n // } />\n // \n // );\n // }\n let parentPath = (parentRoute && parentRoute.path) || \"\";\n warningOnce(\n parentPathname,\n !parentRoute || parentPath.endsWith(\"*\"),\n `You rendered descendant (or called \\`useRoutes()\\`) at ` +\n `\"${parentPathname}\" (under ) but the ` +\n `parent route path has no trailing \"*\". This means if you navigate ` +\n `deeper, the parent won't match anymore and therefore the child ` +\n `routes will never render.\\n\\n` +\n `Please change the parent to .`\n );\n }\n\n let locationFromContext = useLocation();\n\n let location;\n if (locationArg) {\n let parsedLocationArg =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n invariant(\n parentPathnameBase === \"/\" ||\n parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n `When overriding the location using \\`\\` or \\`useRoutes(routes, location)\\`, ` +\n `the location pathname must begin with the portion of the URL pathname that was ` +\n `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n );\n\n location = parsedLocationArg;\n } else {\n location = locationFromContext;\n }\n\n let pathname = location.pathname || \"/\";\n let remainingPathname =\n parentPathnameBase === \"/\"\n ? pathname\n : pathname.slice(parentPathnameBase.length) || \"/\";\n\n let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n if (__DEV__) {\n warning(\n parentRoute || matches != null,\n `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n );\n\n warning(\n matches == null ||\n matches[matches.length - 1].route.element !== undefined ||\n matches[matches.length - 1].route.Component !== undefined,\n `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n `does not have an element or Component. This means it will render an with a ` +\n `null value by default resulting in an \"empty\" page.`\n );\n }\n\n let renderedMatches = _renderMatches(\n matches &&\n matches.map((match) =>\n Object.assign({}, match, {\n params: Object.assign({}, parentParams, match.params),\n pathname: joinPaths([\n parentPathnameBase,\n // Re-encode pathnames that were decoded inside matchRoutes\n navigator.encodeLocation\n ? navigator.encodeLocation(match.pathname).pathname\n : match.pathname,\n ]),\n pathnameBase:\n match.pathnameBase === \"/\"\n ? parentPathnameBase\n : joinPaths([\n parentPathnameBase,\n // Re-encode pathnames that were decoded inside matchRoutes\n navigator.encodeLocation\n ? navigator.encodeLocation(match.pathnameBase).pathname\n : match.pathnameBase,\n ]),\n })\n ),\n parentMatches,\n dataRouterState\n );\n\n // When a user passes in a `locationArg`, the associated routes need to\n // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n // to use the scoped location instead of the global location.\n if (locationArg && renderedMatches) {\n return (\n \n {renderedMatches}\n \n );\n }\n\n return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n let error = useRouteError();\n let message = isRouteErrorResponse(error)\n ? `${error.status} ${error.statusText}`\n : error instanceof Error\n ? error.message\n : JSON.stringify(error);\n let stack = error instanceof Error ? error.stack : null;\n let lightgrey = \"rgba(200,200,200, 0.5)\";\n let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n let devInfo = null;\n if (__DEV__) {\n console.error(\n \"Error handled by React Router default ErrorBoundary:\",\n error\n );\n\n devInfo = (\n <>\n

💿 Hey developer 👋

\n

\n You can provide a way better UX than this when your app throws errors\n by providing your own ErrorBoundary or{\" \"}\n errorElement prop on your route.\n

\n \n );\n }\n\n return (\n <>\n

Unexpected Application Error!

\n

{message}

\n {stack ? 
{stack}
: null}\n {devInfo}\n \n );\n}\n\nconst defaultErrorElement = ;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n location: Location;\n revalidation: RevalidationState;\n error: any;\n component: React.ReactNode;\n routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n location: Location;\n revalidation: RevalidationState;\n error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n RenderErrorBoundaryProps,\n RenderErrorBoundaryState\n> {\n constructor(props: RenderErrorBoundaryProps) {\n super(props);\n this.state = {\n location: props.location,\n revalidation: props.revalidation,\n error: props.error,\n };\n }\n\n static getDerivedStateFromError(error: any) {\n return { error: error };\n }\n\n static getDerivedStateFromProps(\n props: RenderErrorBoundaryProps,\n state: RenderErrorBoundaryState\n ) {\n // When we get into an error state, the user will likely click \"back\" to the\n // previous page that didn't have an error. Because this wraps the entire\n // application, that will have no effect--the error page continues to display.\n // This gives us a mechanism to recover from the error when the location changes.\n //\n // Whether we're in an error state or not, we update the location in state\n // so that when we are in an error state, it gets reset when a new location\n // comes in and the user recovers from the error.\n if (\n state.location !== props.location ||\n (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n ) {\n return {\n error: props.error,\n location: props.location,\n revalidation: props.revalidation,\n };\n }\n\n // If we're not changing locations, preserve the location but still surface\n // any new errors that may come through. We retain the existing error, we do\n // this because the error provided from the app state may be cleared without\n // the location changing.\n return {\n error: props.error || state.error,\n location: state.location,\n revalidation: props.revalidation || state.revalidation,\n };\n }\n\n componentDidCatch(error: any, errorInfo: any) {\n console.error(\n \"React Router caught the following error during render\",\n error,\n errorInfo\n );\n }\n\n render() {\n return this.state.error ? (\n \n \n \n ) : (\n this.props.children\n );\n }\n}\n\ninterface RenderedRouteProps {\n routeContext: RouteContextObject;\n match: RouteMatch;\n children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n let dataRouterContext = React.useContext(DataRouterContext);\n\n // Track how deep we got in our render pass to emulate SSR componentDidCatch\n // in a DataStaticRouter\n if (\n dataRouterContext &&\n dataRouterContext.static &&\n dataRouterContext.staticContext &&\n (match.route.errorElement || match.route.ErrorBoundary)\n ) {\n dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n }\n\n return (\n \n {children}\n \n );\n}\n\nexport function _renderMatches(\n matches: RouteMatch[] | null,\n parentMatches: RouteMatch[] = [],\n dataRouterState: RemixRouter[\"state\"] | null = null\n): React.ReactElement | null {\n if (matches == null) {\n if (dataRouterState?.errors) {\n // Don't bail if we have data router errors so we can render them in the\n // boundary. Use the pre-matched (or shimmed) matches\n matches = dataRouterState.matches as DataRouteMatch[];\n } else {\n return null;\n }\n }\n\n let renderedMatches = matches;\n\n // If we have data errors, trim matches to the highest error boundary\n let errors = dataRouterState?.errors;\n if (errors != null) {\n let errorIndex = renderedMatches.findIndex(\n (m) => m.route.id && errors?.[m.route.id]\n );\n invariant(\n errorIndex >= 0,\n `Could not find a matching route for errors on route IDs: ${Object.keys(\n errors\n ).join(\",\")}`\n );\n renderedMatches = renderedMatches.slice(\n 0,\n Math.min(renderedMatches.length, errorIndex + 1)\n );\n }\n\n return renderedMatches.reduceRight((outlet, match, index) => {\n let error = match.route.id ? errors?.[match.route.id] : null;\n // Only data routers handle errors\n let errorElement: React.ReactNode | null = null;\n if (dataRouterState) {\n errorElement = match.route.errorElement || defaultErrorElement;\n }\n let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n let getChildren = () => {\n let children: React.ReactNode;\n if (error) {\n children = errorElement;\n } else if (match.route.Component) {\n // Note: This is a de-optimized path since React won't re-use the\n // ReactElement since it's identity changes with each new\n // React.createElement call. We keep this so folks can use\n // `` in `` but generally `Component`\n // usage is only advised in `RouterProvider` when we can convert it to\n // `element` ahead of time.\n children = ;\n } else if (match.route.element) {\n children = match.route.element;\n } else {\n children = outlet;\n }\n return (\n \n );\n };\n // Only wrap in an error boundary within data router usages when we have an\n // ErrorBoundary/errorElement on this route. Otherwise let it bubble up to\n // an ancestor ErrorBoundary/errorElement\n return dataRouterState &&\n (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n \n ) : (\n getChildren()\n );\n }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n UseBlocker = \"useBlocker\",\n UseRevalidator = \"useRevalidator\",\n UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n UseBlocker = \"useBlocker\",\n UseLoaderData = \"useLoaderData\",\n UseActionData = \"useActionData\",\n UseRouteError = \"useRouteError\",\n UseNavigation = \"useNavigation\",\n UseRouteLoaderData = \"useRouteLoaderData\",\n UseMatches = \"useMatches\",\n UseRevalidator = \"useRevalidator\",\n UseNavigateStable = \"useNavigate\",\n UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n hookName: DataRouterHook | DataRouterStateHook\n) {\n return `${hookName} must be used within a data router. See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n let ctx = React.useContext(DataRouterContext);\n invariant(ctx, getDataRouterConsoleError(hookName));\n return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n let state = React.useContext(DataRouterStateContext);\n invariant(state, getDataRouterConsoleError(hookName));\n return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n let route = React.useContext(RouteContext);\n invariant(route, getDataRouterConsoleError(hookName));\n return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n let route = useRouteContext(hookName);\n let thisRoute = route.matches[route.matches.length - 1];\n invariant(\n thisRoute.route.id,\n `${hookName} can only be used on routes that contain a unique \"id\"`\n );\n return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n return {\n revalidate: dataRouterContext.router.revalidate,\n state: state.revalidation,\n };\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches() {\n let { matches, loaderData } = useDataRouterState(\n DataRouterStateHook.UseMatches\n );\n return React.useMemo(\n () =>\n matches.map((match) => {\n let { pathname, params } = match;\n // Note: This structure matches that created by createUseMatchesMatch\n // in the @remix-run/router , so if you change this please also change\n // that :) Eventually we'll DRY this up\n return {\n id: match.route.id,\n pathname,\n params,\n data: loaderData[match.route.id] as unknown,\n handle: match.route.handle as unknown,\n };\n }),\n [matches, loaderData]\n );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n if (state.errors && state.errors[routeId] != null) {\n console.error(\n `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n );\n return undefined;\n }\n return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseActionData);\n\n let route = React.useContext(RouteContext);\n invariant(route, `useActionData must be used inside a RouteContext`);\n\n return Object.values(state?.actionData || {})[0];\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error. This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n let error = React.useContext(RouteErrorContext);\n let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n // If this was a render error, we put it in a RouteError context inside\n // of RenderErrorBoundary\n if (error) {\n return error;\n }\n\n // Otherwise look for errors from our data router state\n return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor value\n */\nexport function useAsyncValue(): unknown {\n let value = React.useContext(AwaitContext);\n return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor value\n */\nexport function useAsyncError(): unknown {\n let value = React.useContext(AwaitContext);\n return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation. Mostly used to avoid\n * using half-filled form data. This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n let { router, basename } = useDataRouterContext(DataRouterHook.UseBlocker);\n let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n\n let [blockerKey, setBlockerKey] = React.useState(\"\");\n let blockerFunction = React.useCallback(\n (arg) => {\n if (typeof shouldBlock !== \"function\") {\n return !!shouldBlock;\n }\n if (basename === \"/\") {\n return shouldBlock(arg);\n }\n\n // If they provided us a function and we've got an active basename, strip\n // it from the locations we expose to the user to match the behavior of\n // useLocation\n let { currentLocation, nextLocation, historyAction } = arg;\n return shouldBlock({\n currentLocation: {\n ...currentLocation,\n pathname:\n stripBasename(currentLocation.pathname, basename) ||\n currentLocation.pathname,\n },\n nextLocation: {\n ...nextLocation,\n pathname:\n stripBasename(nextLocation.pathname, basename) ||\n nextLocation.pathname,\n },\n historyAction,\n });\n },\n [basename, shouldBlock]\n );\n\n // This effect is in charge of blocker key assignment and deletion (which is\n // tightly coupled to the key)\n React.useEffect(() => {\n let key = String(++blockerId);\n setBlockerKey(key);\n return () => router.deleteBlocker(key);\n }, [router]);\n\n // This effect handles assigning the blockerFunction. This is to handle\n // unstable blocker function identities, and happens only after the prior\n // effect so we don't get an orphaned blockerFunction in the router with a\n // key of \"\". Until then we just have the IDLE_BLOCKER.\n React.useEffect(() => {\n if (blockerKey !== \"\") {\n router.getBlocker(blockerKey, blockerFunction);\n }\n }, [router, blockerKey, blockerFunction]);\n\n // Prefer the blocker from `state` not `router.state` since DataRouterContext\n // is memoized so this ensures we update on blocker state updates\n return blockerKey && state.blockers.has(blockerKey)\n ? state.blockers.get(blockerKey)!\n : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n let activeRef = React.useRef(false);\n useIsomorphicLayoutEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(activeRef.current, navigateEffectWarning);\n\n // Short circuit here since if this happens on first render the navigate\n // is useless because we haven't wired up our router subscriber yet\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n router.navigate(to);\n } else {\n router.navigate(to, { fromRouteId: id, ...options });\n }\n },\n [router, id]\n );\n\n return navigate;\n}\n\nconst alreadyWarned: Record = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n if (!cond && !alreadyWarned[key]) {\n alreadyWarned[key] = true;\n warning(false, message);\n }\n}\n","import * as React from \"react\";\nimport type {\n TrackedPromise,\n InitialEntry,\n Location,\n MemoryHistory,\n Router as RemixRouter,\n To,\n LazyRouteFunction,\n RelativeRoutingType,\n RouterState,\n} from \"@remix-run/router\";\nimport {\n Action as NavigationType,\n AbortedDeferredError,\n createMemoryHistory,\n UNSAFE_invariant as invariant,\n parsePath,\n resolveTo,\n stripBasename,\n UNSAFE_warning as warning,\n UNSAFE_getPathContributingMatches as getPathContributingMatches,\n} from \"@remix-run/router\";\n\nimport type {\n DataRouteObject,\n IndexRouteObject,\n RouteMatch,\n RouteObject,\n Navigator,\n NonIndexRouteObject,\n} from \"./context\";\nimport {\n LocationContext,\n NavigationContext,\n DataRouterContext,\n DataRouterStateContext,\n AwaitContext,\n RouteContext,\n} from \"./context\";\nimport {\n useAsyncValue,\n useInRouterContext,\n useNavigate,\n useOutlet,\n useRoutes,\n _renderMatches,\n useRoutesImpl,\n useLocation,\n} from \"./hooks\";\n\nexport interface FutureConfig {\n v7_startTransition: boolean;\n}\n\nexport interface RouterProviderProps {\n fallbackElement?: React.ReactNode;\n router: RemixRouter;\n future?: FutureConfig;\n}\n\n/**\n Webpack + React 17 fails to compile on any of the following because webpack\n complains that `startTransition` doesn't exist in `React`:\n * import { startTransition } from \"react\"\n * import * as React from from \"react\";\n \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n * import * as React from from \"react\";\n \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n Moving it to a constant such as the following solves the Webpack/React 17 issue:\n * import * as React from from \"react\";\n const START_TRANSITION = \"startTransition\";\n START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n However, that introduces webpack/terser minification issues in production builds\n in React 18 where minification/obfuscation ends up removing the call of\n React.startTransition entirely from the first half of the ternary. Grabbing\n this exported reference once up front resolves that issue.\n\n See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n fallbackElement,\n router,\n future,\n}: RouterProviderProps): React.ReactElement {\n // Need to use a layout effect here so we are subscribed early enough to\n // pick up on any render-driven redirects/navigations (useEffect/)\n let [state, setStateImpl] = React.useState(router.state);\n let { v7_startTransition } = future || {};\n let setState = React.useCallback(\n (newState: RouterState) => {\n v7_startTransition && startTransitionImpl\n ? startTransitionImpl(() => setStateImpl(newState))\n : setStateImpl(newState);\n },\n [setStateImpl, v7_startTransition]\n );\n React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n let navigator = React.useMemo((): Navigator => {\n return {\n createHref: router.createHref,\n encodeLocation: router.encodeLocation,\n go: (n) => router.navigate(n),\n push: (to, state, opts) =>\n router.navigate(to, {\n state,\n preventScrollReset: opts?.preventScrollReset,\n }),\n replace: (to, state, opts) =>\n router.navigate(to, {\n replace: true,\n state,\n preventScrollReset: opts?.preventScrollReset,\n }),\n };\n }, [router]);\n\n let basename = router.basename || \"/\";\n\n let dataRouterContext = React.useMemo(\n () => ({\n router,\n navigator,\n static: false,\n basename,\n }),\n [router, navigator, basename]\n );\n\n // The fragment and {null} here are important! We need them to keep React 18's\n // useId happy when we are server-rendering since we may have a