{"version":3,"file":"8328.99e0d417.js","mappings":"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","sources":["webpack://@finviz/website/../node_modules/@remix-run/router/dist/router.js","webpack://@finviz/website/../node_modules/path-to-regexp/dist/index.js","webpack://@finviz/website/../node_modules/react-router-dom/dist/index.js","webpack://@finviz/website/../node_modules/react-router/dist/index.js","webpack://@finviz/website/../node_modules/@sentry-internal/browser-utils/build/esm/instrument/xhr.js","webpack://@finviz/website/../node_modules/@sentry-internal/browser-utils/build/esm/types.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/debug-build.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/utils/isSentryRequestUrl.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/integrations/httpclient.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/integrations/inboundfilters.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/integrations/functiontostring.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/sdk.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/vendor/supportsHistory.js","webpack://@finviz/website/../node_modules/@sentry-internal/browser-utils/build/esm/instrument/history.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/error.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/api.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/baseclient.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/envelope.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/utils/parseSampleRate.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/clientreport.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/eventbuilder.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/helpers.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/client.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/utils/sdkMetadata.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/env.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/userfeedback.js","webpack://@finviz/website/../node_modules/@sentry-internal/browser-utils/build/esm/instrument/dom.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/breadcrumbs.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/instrument/console.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/severity.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/breadcrumb-log-level.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/url.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/integrations/breadcrumbs.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/integrations/browserapierrors.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/instrument/globalError.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/instrument/globalUnhandledRejection.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/integrations/globalhandlers.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/integrations/httpcontext.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/aggregate-errors.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/integrations/linkederrors.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/stack-parsers.js","webpack://@finviz/website/../node_modules/@sentry-internal/browser-utils/build/esm/debug-build.js","webpack://@finviz/website/../node_modules/@sentry-internal/browser-utils/build/esm/getNativeImplementation.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/promisebuffer.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/ratelimit.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/transports/base.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/transports/fetch.js","webpack://@finviz/website/../node_modules/@sentry/browser/build/npm/esm/sdk.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/integration.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/integrations/dedupe.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/integrations/extraerrordata.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/metadata.js","webpack://@finviz/website/../node_modules/@sentry/core/build/esm/integrations/third-party-errors-filter.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/dsn.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/envelope.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/instrument/fetch.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/instrument/handlers.js","webpack://@finviz/website/../node_modules/@sentry/utils/build/esm/supports.js"],"sourcesContent":["/**\n * @remix-run/router v1.19.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n _extends = Object.assign ? Object.assign.bind() : function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n return target;\n };\n return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (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 Action[\"Pop\"] = \"POP\";\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 Action[\"Push\"] = \"PUSH\";\n /**\n * A REPLACE indicates the entry at the current index in the history stack\n * being replaced by a new one.\n */\n Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\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 */\nfunction createMemoryHistory(options) {\n if (options === void 0) {\n options = {};\n }\n let {\n initialEntries = [\"/\"],\n initialIndex,\n v5Compat = false\n } = options;\n let entries; // Declare so we can access from createMemoryLocation\n entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n let action = Action.Pop;\n let listener = null;\n function clampIndex(n) {\n return Math.min(Math.max(n, 0), entries.length - 1);\n }\n function getCurrentLocation() {\n return entries[index];\n }\n function createMemoryLocation(to, state, key) {\n if (state === void 0) {\n state = null;\n }\n let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n return location;\n }\n function createHref(to) {\n return typeof to === \"string\" ? to : createPath(to);\n }\n let history = {\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) {\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({\n action,\n location: nextLocation,\n delta: 1\n });\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({\n action,\n location: nextLocation,\n delta: 0\n });\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({\n action,\n location: nextLocation,\n delta\n });\n }\n },\n listen(fn) {\n listener = fn;\n return () => {\n listener = null;\n };\n }\n };\n return history;\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 */\nfunction createBrowserHistory(options) {\n if (options === void 0) {\n options = {};\n }\n function createBrowserLocation(window, globalHistory) {\n let {\n pathname,\n search,\n hash\n } = window.location;\n return createLocation(\"\", {\n pathname,\n search,\n hash\n },\n // state defaults to `null` because `window.history.state` does\n globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n }\n function createBrowserHref(window, to) {\n return typeof to === \"string\" ? to : createPath(to);\n }\n return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\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 */\nfunction createHashHistory(options) {\n if (options === void 0) {\n options = {};\n }\n function createHashLocation(window, globalHistory) {\n let {\n pathname = \"/\",\n search = \"\",\n hash = \"\"\n } = parsePath(window.location.hash.substr(1));\n // Hash URL should always have a leading / just like window.location.pathname\n // does, so if an app ends up at a route like /#something then we add a\n // leading slash so all of our path-matching behaves the same as if it would\n // in a browser router. This is particularly important when there exists a\n // root splat route () since that matches internally against\n // \"/*\" and we'd expect /#something to 404 in a hash router app.\n if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n pathname = \"/\" + pathname;\n }\n return createLocation(\"\", {\n pathname,\n search,\n hash\n },\n // state defaults to `null` because `window.history.state` does\n globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n }\n function createHashHref(window, to) {\n let base = window.document.querySelector(\"base\");\n let href = \"\";\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 return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n }\n function validateHashLocation(location, to) {\n warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n }\n return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n if (value === false || value === null || typeof value === \"undefined\") {\n throw new Error(message);\n }\n}\nfunction warning(cond, message) {\n if (!cond) {\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\") console.warn(message);\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}\nfunction createKey() {\n return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n return {\n usr: location.state,\n key: location.key,\n idx: index\n };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n if (state === void 0) {\n state = null;\n }\n let location = _extends({\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.key || key || createKey()\n });\n return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n let {\n pathname = \"/\",\n search = \"\",\n hash = \"\"\n } = _ref;\n if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n let parsedPath = {};\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 let searchIndex = path.indexOf(\"?\");\n if (searchIndex >= 0) {\n parsedPath.search = path.substr(searchIndex);\n path = path.substr(0, searchIndex);\n }\n if (path) {\n parsedPath.pathname = path;\n }\n }\n return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n if (options === void 0) {\n options = {};\n }\n let {\n window = document.defaultView,\n v5Compat = false\n } = options;\n let globalHistory = window.history;\n let action = Action.Pop;\n let listener = null;\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(_extends({}, globalHistory.state, {\n idx: index\n }), \"\");\n }\n function getIndex() {\n let state = globalHistory.state || {\n idx: null\n };\n return state.idx;\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({\n action,\n location: history.location,\n delta\n });\n }\n }\n function push(to, state) {\n action = Action.Push;\n let location = createLocation(history.location, to, state);\n if (validateLocation) validateLocation(location, to);\n index = getIndex() + 1;\n let historyState = getHistoryState(location, index);\n let url = history.createHref(location);\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 if (v5Compat && listener) {\n listener({\n action,\n location: history.location,\n delta: 1\n });\n }\n }\n function replace(to, state) {\n action = Action.Replace;\n let location = createLocation(history.location, to, state);\n if (validateLocation) validateLocation(location, to);\n index = getIndex();\n let historyState = getHistoryState(location, index);\n let url = history.createHref(location);\n globalHistory.replaceState(historyState, \"\", url);\n if (v5Compat && listener) {\n listener({\n action,\n location: history.location,\n delta: 0\n });\n }\n }\n function createURL(to) {\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 = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n let href = typeof to === \"string\" ? to : createPath(to);\n // Treating this as a full URL will strip any trailing spaces so we need to\n // pre-encode them since they might be part of a matching splat param from\n // an ancestor route\n href = href.replace(/ $/, \"%20\");\n invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n return new URL(href, base);\n }\n let history = {\n get action() {\n return action;\n },\n get location() {\n return getLocation(window, globalHistory);\n },\n listen(fn) {\n if (listener) {\n throw new Error(\"A history only accepts one active listener\");\n }\n window.addEventListener(PopStateEventType, handlePop);\n listener = fn;\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 return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n ResultType[\"data\"] = \"data\";\n ResultType[\"deferred\"] = \"deferred\";\n ResultType[\"redirect\"] = \"redirect\";\n ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n if (parentPath === void 0) {\n parentPath = [];\n }\n if (manifest === void 0) {\n manifest = {};\n }\n return routes.map((route, index) => {\n let treePath = [...parentPath, String(index)];\n let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\". Route \" + \"id's must be globally unique within Data Router usages\");\n if (isIndexRoute(route)) {\n let indexRoute = _extends({}, route, mapRouteProperties(route), {\n id\n });\n manifest[id] = indexRoute;\n return indexRoute;\n } else {\n let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n id,\n children: undefined\n });\n manifest[id] = pathOrLayoutRoute;\n if (route.children) {\n pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n }\n return pathOrLayoutRoute;\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 */\nfunction matchRoutes(routes, locationArg, basename) {\n if (basename === void 0) {\n basename = \"/\";\n }\n return matchRoutesImpl(routes, locationArg, basename, false);\n}\nfunction matchRoutesImpl(routes, locationArg, basename, allowPartial) {\n let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n let pathname = stripBasename(location.pathname || \"/\", basename);\n if (pathname == null) {\n return null;\n }\n let branches = flattenRoutes(routes);\n rankRouteBranches(branches);\n let matches = null;\n for (let i = 0; matches == null && i < branches.length; ++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 let decoded = decodePath(pathname);\n matches = matchRouteBranch(branches[i], decoded, allowPartial);\n }\n return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n let {\n route,\n pathname,\n params\n } = match;\n return {\n id: route.id,\n pathname,\n params,\n data: loaderData[route.id],\n handle: route.handle\n };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n if (branches === void 0) {\n branches = [];\n }\n if (parentsMeta === void 0) {\n parentsMeta = [];\n }\n if (parentPath === void 0) {\n parentPath = \"\";\n }\n let flattenRoute = (route, index, relativePath) => {\n let meta = {\n relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n caseSensitive: route.caseSensitive === true,\n childrenIndex: index,\n route\n };\n if (meta.relativePath.startsWith(\"/\")) {\n invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n meta.relativePath = meta.relativePath.slice(parentPath.length);\n }\n let path = joinPaths([parentPath, meta.relativePath]);\n let routesMeta = parentsMeta.concat(meta);\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, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n flattenRoutes(route.children, branches, routesMeta, path);\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 branches.push({\n path,\n score: computeScore(path, route.index),\n routesMeta\n });\n };\n routes.forEach((route, index) => {\n var _route$path;\n // coarse-grain check for optional params\n if (route.path === \"\" || !((_route$path = route.path) != null && _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 return branches;\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) {\n let segments = path.split(\"/\");\n if (segments.length === 0) return [];\n let [first, ...rest] = segments;\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 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 let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n let result = [];\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 explode _earlier_\n // then /:one. By always including the parent as required _for all children_\n // first, we avoid this issue\n result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n // Then, if this is an optional value, add all child versions without\n if (isOptional) {\n result.push(...restExploded);\n }\n // for absolute paths, ensure `/` instead of empty segment\n return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n let segments = path.split(\"/\");\n let initialScore = segments.length;\n if (segments.some(isSplat)) {\n initialScore += splatPenalty;\n }\n if (index) {\n initialScore += indexRouteValue;\n }\n return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\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}\nfunction matchRouteBranch(branch, pathname, allowPartial) {\n if (allowPartial === void 0) {\n allowPartial = false;\n }\n let {\n routesMeta\n } = branch;\n let matchedParams = {};\n let matchedPathname = \"/\";\n let matches = [];\n for (let i = 0; i < routesMeta.length; ++i) {\n let meta = routesMeta[i];\n let end = i === routesMeta.length - 1;\n let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n let match = matchPath({\n path: meta.relativePath,\n caseSensitive: meta.caseSensitive,\n end\n }, remainingPathname);\n let route = meta.route;\n if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {\n match = matchPath({\n path: meta.relativePath,\n caseSensitive: meta.caseSensitive,\n end: false\n }, remainingPathname);\n }\n if (!match) {\n return null;\n }\n Object.assign(matchedParams, match.params);\n matches.push({\n // TODO: Can this as be avoided?\n params: matchedParams,\n pathname: joinPaths([matchedPathname, match.pathname]),\n pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n route\n });\n if (match.pathnameBase !== \"/\") {\n matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n }\n }\n return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n if (params === void 0) {\n params = {};\n }\n let path = originalPath;\n if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n path = path.replace(/\\*$/, \"/*\");\n }\n // ensure `/` is added at the beginning if the path is absolute\n const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n const segments = path.split(/\\/+/).map((segment, index, array) => {\n const isLastSegment = index === array.length - 1;\n // only apply the splat if it's the last segment\n if (isLastSegment && segment === \"*\") {\n const star = \"*\";\n // Apply the splat\n return stringify(params[star]);\n }\n const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n if (keyMatch) {\n const [, key, optional] = keyMatch;\n let param = params[key];\n invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n return stringify(param);\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 return prefix + segments.join(\"/\");\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 */\nfunction matchPath(pattern, pathname) {\n if (typeof pattern === \"string\") {\n pattern = {\n path: pattern,\n caseSensitive: false,\n end: true\n };\n }\n let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n let match = pathname.match(matcher);\n if (!match) return null;\n let matchedPathname = match[0];\n let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n let captureGroups = match.slice(1);\n let params = compiledParams.reduce((memo, _ref, index) => {\n let {\n paramName,\n isOptional\n } = _ref;\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.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n }\n const value = captureGroups[index];\n if (isOptional && !value) {\n memo[paramName] = undefined;\n } else {\n memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n }\n return memo;\n }, {});\n return {\n params,\n pathname: matchedPathname,\n pathnameBase,\n pattern\n };\n}\nfunction compilePath(path, caseSensitive, end) {\n if (caseSensitive === void 0) {\n caseSensitive = false;\n }\n if (end === void 0) {\n end = true;\n }\n warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n let params = [];\n let regexpSource = \"^\" + path.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, (_, paramName, isOptional) => {\n params.push({\n paramName,\n isOptional: isOptional != null\n });\n return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n });\n if (path.endsWith(\"*\")) {\n params.push({\n paramName: \"*\"\n });\n regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // 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 let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n return [matcher, params];\n}\nfunction decodePath(value) {\n try {\n return value.split(\"/\").map(v => decodeURIComponent(v).replace(/\\//g, \"%2F\")).join(\"/\");\n } catch (error) {\n warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n return value;\n }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n if (basename === \"/\") return pathname;\n if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n return null;\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(\"/\") ? basename.length - 1 : basename.length;\n let nextChar = pathname.charAt(startIndex);\n if (nextChar && nextChar !== \"/\") {\n // pathname does not start with basename/\n return null;\n }\n return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n if (fromPathname === void 0) {\n fromPathname = \"/\";\n }\n let {\n pathname: toPathname,\n search = \"\",\n hash = \"\"\n } = typeof to === \"string\" ? parsePath(to) : to;\n let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n return {\n pathname,\n search: normalizeSearch(search),\n hash: normalizeHash(hash)\n };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n let relativeSegments = relativePath.split(\"/\");\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 return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"]. Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in and the router will parse it for you.\";\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 */\nfunction getPathContributingMatches(matches) {\n return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n let pathMatches = getPathContributingMatches(matches);\n // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n // match so we include splat values for \".\" links. See:\n // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n if (v7_relativeSplatPath) {\n return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);\n }\n return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n if (isPathRelative === void 0) {\n isPathRelative = false;\n }\n let to;\n if (typeof toArg === \"string\") {\n to = parsePath(toArg);\n } else {\n to = _extends({}, toArg);\n invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n }\n let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n let toPathname = isEmptyPath ? \"/\" : to.pathname;\n let from;\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 (toPathname == null) {\n from = locationPathname;\n } else {\n let routePathnameIndex = routePathnames.length - 1;\n // With relative=\"route\" (the default), each leading .. segment means\n // \"go up one route\" instead of \"go up one URL segment\". This is a key\n // difference from how works and a major reason we call this a\n // \"to\" value instead of a \"href\".\n if (!isPathRelative && toPathname.startsWith(\"..\")) {\n let toSegments = toPathname.split(\"/\");\n while (toSegments[0] === \"..\") {\n toSegments.shift();\n routePathnameIndex -= 1;\n }\n to.pathname = toSegments.join(\"/\");\n }\n from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n }\n let path = resolvePath(to, from);\n // Ensure the pathname has a trailing slash if the original \"to\" had one\n let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n // Or if this was a link to the current path which has a trailing slash\n let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n path.pathname += \"/\";\n }\n return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n // Empty strings should be treated the same as / paths\n return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nconst json = function json(data, init) {\n if (init === void 0) {\n init = {};\n }\n let responseInit = typeof init === \"number\" ? {\n status: init\n } : init;\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 return new Response(JSON.stringify(data), _extends({}, responseInit, {\n headers\n }));\n};\nclass DataWithResponseInit {\n constructor(data, init) {\n this.type = \"DataWithResponseInit\";\n this.data = data;\n this.init = init || null;\n }\n}\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nfunction data(data, init) {\n return new DataWithResponseInit(data, typeof init === \"number\" ? {\n status: init\n } : init);\n}\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n constructor(data, responseInit) {\n this.pendingKeysSet = new Set();\n this.subscribers = new Set();\n this.deferredKeys = [];\n invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n // Set up an AbortController + Promise we can race against to exit early\n // cancellation\n let reject;\n this.abortPromise = new Promise((_, r) => reject = r);\n this.controller = new AbortController();\n let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n this.controller.signal.addEventListener(\"abort\", onAbort);\n this.data = Object.entries(data).reduce((acc, _ref2) => {\n let [key, value] = _ref2;\n return Object.assign(acc, {\n [key]: this.trackPromise(key, value)\n });\n }, {});\n if (this.done) {\n // All incoming values were resolved\n this.unlistenAbortSignal();\n }\n this.init = responseInit;\n }\n trackPromise(key, value) {\n if (!(value instanceof Promise)) {\n return value;\n }\n this.deferredKeys.push(key);\n this.pendingKeysSet.add(key);\n // We store a little wrapper promise that will be extended with\n // _data/_error props upon resolve/reject\n let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n // Register rejection listeners to avoid uncaught promise rejections on\n // errors or aborted deferred values\n promise.catch(() => {});\n Object.defineProperty(promise, \"_tracked\", {\n get: () => true\n });\n return promise;\n }\n onSettle(promise, key, error, data) {\n if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n this.unlistenAbortSignal();\n Object.defineProperty(promise, \"_error\", {\n get: () => error\n });\n return Promise.reject(error);\n }\n this.pendingKeysSet.delete(key);\n if (this.done) {\n // Nothing left to abort!\n this.unlistenAbortSignal();\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(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n Object.defineProperty(promise, \"_error\", {\n get: () => undefinedError\n });\n this.emit(false, key);\n return Promise.reject(undefinedError);\n }\n if (data === undefined) {\n Object.defineProperty(promise, \"_error\", {\n get: () => error\n });\n this.emit(false, key);\n return Promise.reject(error);\n }\n Object.defineProperty(promise, \"_data\", {\n get: () => data\n });\n this.emit(false, key);\n return data;\n }\n emit(aborted, settledKey) {\n this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n }\n subscribe(fn) {\n this.subscribers.add(fn);\n return () => this.subscribers.delete(fn);\n }\n cancel() {\n this.controller.abort();\n this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n this.emit(true);\n }\n async resolveData(signal) {\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 get done() {\n return this.pendingKeysSet.size === 0;\n }\n get unwrappedData() {\n invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n return Object.entries(this.data).reduce((acc, _ref3) => {\n let [key, value] = _ref3;\n return Object.assign(acc, {\n [key]: unwrapTrackedPromise(value)\n });\n }, {});\n }\n get pendingKeys() {\n return Array.from(this.pendingKeysSet);\n }\n}\nfunction isTrackedPromise(value) {\n return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n if (!isTrackedPromise(value)) {\n return value;\n }\n if (value._error) {\n throw value._error;\n }\n return value._data;\n}\nconst defer = function defer(data, init) {\n if (init === void 0) {\n init = {};\n }\n let responseInit = typeof init === \"number\" ? {\n status: init\n } : init;\n return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n if (init === void 0) {\n init = 302;\n }\n let responseInit = init;\n if (typeof responseInit === \"number\") {\n responseInit = {\n status: responseInit\n };\n } else if (typeof responseInit.status === \"undefined\") {\n responseInit.status = 302;\n }\n let headers = new Headers(responseInit.headers);\n headers.set(\"Location\", url);\n return new Response(null, _extends({}, responseInit, {\n headers\n }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n let response = redirect(url, init);\n response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n return response;\n};\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst replace = (url, init) => {\n let response = redirect(url, init);\n response.headers.set(\"X-Remix-Replace\", \"true\");\n return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n constructor(status, statusText, data, internal) {\n if (internal === void 0) {\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 * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\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};\nconst IDLE_FETCHER = {\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};\nconst IDLE_BLOCKER = {\n state: \"unblocked\",\n proceed: undefined,\n reset: undefined,\n location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n const isServer = !isBrowser;\n invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n let mapRouteProperties;\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 // Routes keyed by ID\n let manifest = {};\n // Routes in tree format for matching\n let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n let inFlightDataRoutes;\n let basename = init.basename || \"/\";\n let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;\n let patchRoutesOnMissImpl = init.unstable_patchRoutesOnMiss;\n // Config driven behavior flags\n let future = _extends({\n v7_fetcherPersist: false,\n v7_normalizeFormMethod: false,\n v7_partialHydration: false,\n v7_prependBasename: false,\n v7_relativeSplatPath: false,\n v7_skipActionErrorRevalidation: false\n }, init.future);\n // Cleanup function for history\n let unlistenHistory = 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 = null;\n // Externally-provided function to get scroll restoration keys\n let getScrollRestorationKey = null;\n // Externally-provided function to get current scroll position\n let getScrollPosition = 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 let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n let initialErrors = null;\n if (initialMatches == null && !patchRoutesOnMissImpl) {\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 {\n matches,\n route\n } = getShortCircuitMatches(dataRoutes);\n initialMatches = matches;\n initialErrors = {\n [route.id]: error\n };\n }\n // In SPA apps, if the user provided a patchRoutesOnMiss implementation and\n // our initial match is a splat route, clear them out so we run through lazy\n // discovery on hydration in case there's a more accurate lazy route match.\n // In SSR apps (with `hydrationData`), we expect that the server will send\n // up the proper matched routes so we don't want to run lazy discovery on\n // initial hydration and want to hydrate into the splat route.\n if (initialMatches && !init.hydrationData) {\n let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);\n if (fogOfWar.active) {\n initialMatches = null;\n }\n }\n let initialized;\n if (!initialMatches) {\n initialized = false;\n initialMatches = [];\n // If partial hydration and fog of war is enabled, we will be running\n // `patchRoutesOnMiss` during hydration so include any partial matches as\n // the initial matches so we can properly render `HydrateFallback`'s\n if (future.v7_partialHydration) {\n let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);\n if (fogOfWar.active && fogOfWar.matches) {\n initialMatches = fogOfWar.matches;\n }\n }\n } else if (initialMatches.some(m => m.route.lazy)) {\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 initialized = false;\n } else if (!initialMatches.some(m => m.route.loader)) {\n // If we've got no loaders to run, then we're good to go\n initialized = true;\n } else if (future.v7_partialHydration) {\n // If partial hydration is enabled, we're initialized so long as we were\n // provided with hydrationData for every route with a loader, and no loaders\n // were marked for explicit hydration\n let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n let errors = init.hydrationData ? init.hydrationData.errors : null;\n let isRouteInitialized = m => {\n // No loader, nothing to initialize\n if (!m.route.loader) {\n return true;\n }\n // Explicitly opting-in to running on hydration\n if (typeof m.route.loader === \"function\" && m.route.loader.hydrate === true) {\n return false;\n }\n // Otherwise, initialized if hydrated with data or an error\n return loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined;\n };\n // If errors exist, don't consider routes below the boundary\n if (errors) {\n let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);\n initialized = initialMatches.slice(0, idx + 1).every(isRouteInitialized);\n } else {\n initialized = initialMatches.every(isRouteInitialized);\n }\n } else {\n // Without partial hydration - we're initialized if we were provided any\n // hydrationData - which is expected to be complete\n initialized = init.hydrationData != null;\n }\n let router;\n let state = {\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 // -- Stateful internal variables to manage navigations --\n // Current navigation in progress (to be committed in completeNavigation)\n let pendingAction = Action.Pop;\n // Should the current navigation prevent the scroll reset if scroll cannot\n // be restored?\n let pendingPreventScrollReset = false;\n // AbortController for the active navigation\n let pendingNavigationController;\n // Should the current navigation enable document.startViewTransition?\n let pendingViewTransitionEnabled = false;\n // Store applied view transitions so we can apply them on POP\n let appliedViewTransitions = new Map();\n // Cleanup function for persisting applied transitions to sessionStorage\n let removePageHideEventListener = null;\n // We use this to avoid touching history in completeNavigation if a\n // revalidation is entirely uninterrupted\n let isUninterruptedRevalidation = false;\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 // Use this internal array to capture routes that require revalidation due\n // to a cancelled deferred on action submission\n let cancelledDeferredRoutes = [];\n // Use this internal array to capture fetcher loads that were cancelled by an\n // action navigation and require revalidation\n let cancelledFetcherLoads = new Set();\n // AbortControllers for any in-flight fetchers\n let fetchControllers = new Map();\n // Track loads based on the order in which they started\n let incrementingLoadId = 0;\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 // Fetchers that triggered data reloads as a result of their actions\n let fetchReloadIds = new Map();\n // Fetchers that triggered redirect navigations\n let fetchRedirectIds = new Set();\n // Most recent href/match for fetcher.load calls for fetchers\n let fetchLoadMatches = new Map();\n // Ref-count mounted fetchers so we know when it's ok to clean them up\n let activeFetchers = new Map();\n // Fetchers that have requested a delete when using v7_fetcherPersist,\n // they'll be officially removed after they return to idle\n let deletedFetchers = new Set();\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 // 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 // Map of pending patchRoutesOnMiss() promises (keyed by path/matches) so\n // that we only kick them off once for a given combo\n let pendingPatchRoutes = new Map();\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 // 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(_ref => {\n let {\n action: historyAction,\n location,\n delta\n } = _ref;\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 warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs. This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n let blockerKey = shouldBlockNavigation({\n currentLocation: state.location,\n nextLocation: location,\n historyAction\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 // 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({\n blockers\n });\n }\n });\n return;\n }\n return startNavigation(historyAction, location);\n });\n if (isBrowser) {\n // FIXME: This feels gross. How can we cleanup the lines between\n // scrollRestoration/appliedTransitions persistance?\n restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\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(Action.Pop, state.location, {\n initialHydration: true\n });\n }\n return router;\n }\n // Clean up a router and it's side effects\n function dispose() {\n if (unlistenHistory) {\n unlistenHistory();\n }\n if (removePageHideEventListener) {\n removePageHideEventListener();\n }\n subscribers.clear();\n pendingNavigationController && pendingNavigationController.abort();\n state.fetchers.forEach((_, key) => deleteFetcher(key));\n state.blockers.forEach((_, key) => deleteBlocker(key));\n }\n // Subscribe to state updates for the router\n function subscribe(fn) {\n subscribers.add(fn);\n return () => subscribers.delete(fn);\n }\n // Update our state and notify the calling context of the change\n function updateState(newState, opts) {\n if (opts === void 0) {\n opts = {};\n }\n state = _extends({}, state, newState);\n // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n // can be removed\n let completedFetchers = [];\n let deletedFetchersKeys = [];\n if (future.v7_fetcherPersist) {\n state.fetchers.forEach((fetcher, key) => {\n if (fetcher.state === \"idle\") {\n if (deletedFetchers.has(key)) {\n // Unmounted from the UI and can be totally removed\n deletedFetchersKeys.push(key);\n } else {\n // Returned to idle but still mounted in the UI, so semi-remains for\n // revalidations and such\n completedFetchers.push(key);\n }\n }\n });\n }\n // Iterate over a local copy so that if flushSync is used and we end up\n // removing and adding a new subscriber due to the useCallback dependencies,\n // we don't get ourselves into a loop calling the new subscriber immediately\n [...subscribers].forEach(subscriber => subscriber(state, {\n deletedFetchers: deletedFetchersKeys,\n unstable_viewTransitionOpts: opts.viewTransitionOpts,\n unstable_flushSync: opts.flushSync === true\n }));\n // Remove idle fetchers from state since we only care about in-flight fetchers.\n if (future.v7_fetcherPersist) {\n completedFetchers.forEach(key => state.fetchers.delete(key));\n deletedFetchersKeys.forEach(key => deleteFetcher(key));\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(location, newState, _temp) {\n var _location$state, _location$state2;\n let {\n flushSync\n } = _temp === void 0 ? {} : _temp;\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 = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n let actionData;\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 // Always preserve any existing loaderData from re-used routes\n let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\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 // Always respect the user flag. Otherwise don't reset on mutation\n // submission navigations unless they redirect\n let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n if (inFlightDataRoutes) {\n dataRoutes = inFlightDataRoutes;\n inFlightDataRoutes = undefined;\n }\n if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n init.history.push(location, location.state);\n } else if (pendingAction === Action.Replace) {\n init.history.replace(location, location.state);\n }\n let viewTransitionOpts;\n // On POP, enable transitions if they were enabled on the original navigation\n if (pendingAction === Action.Pop) {\n // Forward takes precedence so they behave like the original navigation\n let priorPaths = appliedViewTransitions.get(state.location.pathname);\n if (priorPaths && priorPaths.has(location.pathname)) {\n viewTransitionOpts = {\n currentLocation: state.location,\n nextLocation: location\n };\n } else if (appliedViewTransitions.has(location.pathname)) {\n // If we don't have a previous forward nav, assume we're popping back to\n // the new location and enable if that location previously enabled\n viewTransitionOpts = {\n currentLocation: location,\n nextLocation: state.location\n };\n }\n } else if (pendingViewTransitionEnabled) {\n // Store the applied transition on PUSH/REPLACE\n let toPaths = appliedViewTransitions.get(state.location.pathname);\n if (toPaths) {\n toPaths.add(location.pathname);\n } else {\n toPaths = new Set([location.pathname]);\n appliedViewTransitions.set(state.location.pathname, toPaths);\n }\n viewTransitionOpts = {\n currentLocation: state.location,\n nextLocation: location\n };\n }\n updateState(_extends({}, newState, {\n actionData,\n loaderData,\n historyAction: pendingAction,\n location,\n initialized: true,\n navigation: IDLE_NAVIGATION,\n revalidation: \"idle\",\n restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n preventScrollReset,\n blockers\n }), {\n viewTransitionOpts,\n flushSync: flushSync === true\n });\n // Reset stateful navigation vars\n pendingAction = Action.Pop;\n pendingPreventScrollReset = false;\n pendingViewTransitionEnabled = false;\n isUninterruptedRevalidation = false;\n isRevalidationRequired = false;\n cancelledDeferredRoutes = [];\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(to, opts) {\n if (typeof to === \"number\") {\n init.history.go(to);\n return;\n }\n let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n let {\n path,\n submission,\n error\n } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n let currentLocation = state.location;\n let nextLocation = createLocation(state.location, path, opts && opts.state);\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 = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n let historyAction = Action.Push;\n if (userReplace === true) {\n historyAction = Action.Replace;\n } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\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 = Action.Replace;\n }\n let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n let flushSync = (opts && opts.unstable_flushSync) === true;\n let blockerKey = shouldBlockNavigation({\n currentLocation,\n nextLocation,\n historyAction\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({\n blockers\n });\n }\n });\n return;\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 enableViewTransition: opts && opts.unstable_viewTransition,\n flushSync\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({\n 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 // 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 // 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(pendingAction || state.historyAction, state.navigation.location, {\n overrideNavigation: state.navigation\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(historyAction, location, opts) {\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 = (opts && opts.startUninterruptedRevalidation) === true;\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 pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let loadingNavigation = opts && opts.overrideNavigation;\n let matches = matchRoutes(routesToUse, location, basename);\n let flushSync = (opts && opts.flushSync) === true;\n let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n if (fogOfWar.active && fogOfWar.matches) {\n matches = fogOfWar.matches;\n }\n // Short circuit with a 404 on the root error boundary if we match nothing\n if (!matches) {\n let {\n error,\n notFoundMatches,\n route\n } = handleNavigational404(location.pathname);\n completeNavigation(location, {\n matches: notFoundMatches,\n loaderData: {},\n errors: {\n [route.id]: error\n }\n }, {\n flushSync\n });\n return;\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 (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n completeNavigation(location, {\n matches\n }, {\n flushSync\n });\n return;\n }\n // Create a controller/Request for this navigation\n pendingNavigationController = new AbortController();\n let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n let pendingActionResult;\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 pendingActionResult = [findNearestBoundary(matches).route.id, {\n type: ResultType.error,\n error: opts.pendingError\n }];\n } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n // Call action if we received an action submission\n let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {\n replace: opts.replace,\n flushSync\n });\n if (actionResult.shortCircuited) {\n return;\n }\n // If we received a 404 from handleAction, it's because we couldn't lazily\n // discover the destination route so we don't want to call loaders\n if (actionResult.pendingActionResult) {\n let [routeId, result] = actionResult.pendingActionResult;\n if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {\n pendingNavigationController = null;\n completeNavigation(location, {\n matches: actionResult.matches,\n loaderData: {},\n errors: {\n [routeId]: result.error\n }\n });\n return;\n }\n }\n matches = actionResult.matches || matches;\n pendingActionResult = actionResult.pendingActionResult;\n loadingNavigation = getLoadingNavigation(location, opts.submission);\n flushSync = false;\n // No need to do fog of war matching again on loader execution\n fogOfWar.active = false;\n // Create a GET request for the loaders\n request = createClientSideRequest(init.history, request.url, request.signal);\n }\n // Call loaders\n let {\n shortCircuited,\n matches: updatedMatches,\n loaderData,\n errors\n } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);\n if (shortCircuited) {\n return;\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 completeNavigation(location, _extends({\n matches: updatedMatches || matches\n }, getActionDataForCommit(pendingActionResult), {\n loaderData,\n errors\n }));\n }\n // Call the action matched by the leaf route for this navigation and handle\n // redirects/errors\n async function handleAction(request, location, submission, matches, isFogOfWar, opts) {\n if (opts === void 0) {\n opts = {};\n }\n interruptActiveLoads();\n // Put us in a submitting state\n let navigation = getSubmittingNavigation(location, submission);\n updateState({\n navigation\n }, {\n flushSync: opts.flushSync === true\n });\n if (isFogOfWar) {\n let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n if (discoverResult.type === \"aborted\") {\n return {\n shortCircuited: true\n };\n } else if (discoverResult.type === \"error\") {\n let {\n boundaryId,\n error\n } = handleDiscoverRouteError(location.pathname, discoverResult);\n return {\n matches: discoverResult.partialMatches,\n pendingActionResult: [boundaryId, {\n type: ResultType.error,\n error\n }]\n };\n } else if (!discoverResult.matches) {\n let {\n notFoundMatches,\n error,\n route\n } = handleNavigational404(location.pathname);\n return {\n matches: notFoundMatches,\n pendingActionResult: [route.id, {\n type: ResultType.error,\n error\n }]\n };\n } else {\n matches = discoverResult.matches;\n }\n }\n // Call our action and get the result\n let result;\n let actionMatch = getTargetMatch(matches, location);\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 let results = await callDataStrategy(\"action\", request, [actionMatch], matches);\n result = results[0];\n if (request.signal.aborted) {\n return {\n shortCircuited: true\n };\n }\n }\n if (isRedirectResult(result)) {\n let replace;\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 let location = normalizeRedirectLocation(result.response.headers.get(\"Location\"), new URL(request.url), basename);\n replace = location === state.location.pathname + state.location.search;\n }\n await startRedirectNavigation(request, result, {\n submission,\n replace\n });\n return {\n shortCircuited: true\n };\n }\n if (isDeferredResult(result)) {\n throw getInternalRouterError(400, {\n type: \"defer-action\"\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 // By default, all submissions to the current location are REPLACE\n // navigations, but if the action threw an error that'll be rendered in\n // an errorElement, we fall back to PUSH so that the user can use the\n // back button to get back to the pre-submission form location to try\n // again\n if ((opts && opts.replace) !== true) {\n pendingAction = Action.Push;\n }\n return {\n matches,\n pendingActionResult: [boundaryMatch.route.id, result]\n };\n }\n return {\n matches,\n pendingActionResult: [actionMatch.route.id, result]\n };\n }\n // Call all applicable loaders for the given matches, handling redirects,\n // errors, etc.\n async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {\n // Figure out the right navigation we want to use for data loading\n let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\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 = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\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 we have partialHydration enabled, then don't update the state for the\n // initial data load since it's not a \"navigation\"\n let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);\n // When fog of war is enabled, we enter our `loading` state earlier so we\n // can discover new routes during the `loading` state. We skip this if\n // we've already run actions since we would have done our matching already.\n // If the children() function threw then, we want to proceed with the\n // partial matches it discovered.\n if (isFogOfWar) {\n if (shouldUpdateNavigationState) {\n let actionData = getUpdatedActionData(pendingActionResult);\n updateState(_extends({\n navigation: loadingNavigation\n }, actionData !== undefined ? {\n actionData\n } : {}), {\n flushSync\n });\n }\n let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n if (discoverResult.type === \"aborted\") {\n return {\n shortCircuited: true\n };\n } else if (discoverResult.type === \"error\") {\n let {\n boundaryId,\n error\n } = handleDiscoverRouteError(location.pathname, discoverResult);\n return {\n matches: discoverResult.partialMatches,\n loaderData: {},\n errors: {\n [boundaryId]: error\n }\n };\n } else if (!discoverResult.matches) {\n let {\n error,\n notFoundMatches,\n route\n } = handleNavigational404(location.pathname);\n return {\n matches: notFoundMatches,\n loaderData: {},\n errors: {\n [route.id]: error\n }\n };\n } else {\n matches = discoverResult.matches;\n }\n }\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);\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(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n pendingNavigationLoadId = ++incrementingLoadId;\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, _extends({\n matches,\n loaderData: {},\n // Commit pending error if we're short circuiting\n errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n [pendingActionResult[0]]: pendingActionResult[1].error\n } : null\n }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {\n fetchers: new Map(state.fetchers)\n } : {}), {\n flushSync\n });\n return {\n shortCircuited: true\n };\n }\n if (shouldUpdateNavigationState) {\n let updates = {};\n if (!isFogOfWar) {\n // Only update navigation/actionNData if we didn't already do it above\n updates.navigation = loadingNavigation;\n let actionData = getUpdatedActionData(pendingActionResult);\n if (actionData !== undefined) {\n updates.actionData = actionData;\n }\n }\n if (revalidatingFetchers.length > 0) {\n updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n }\n updateState(updates, {\n flushSync\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 // Proxy navigation abort through to revalidation fetchers\n let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n if (pendingNavigationController) {\n pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n }\n let {\n loaderResults,\n fetcherResults\n } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n if (request.signal.aborted) {\n return {\n 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(\"abort\", abortPendingFetchRevalidations);\n }\n revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n // If any loaders returned a redirect Response, start a new REPLACE navigation\n let redirect = findRedirect([...loaderResults, ...fetcherResults]);\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 = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n fetchRedirectIds.add(fetcherKey);\n }\n await startRedirectNavigation(request, redirect.result, {\n replace\n });\n return {\n shortCircuited: true\n };\n }\n // Process and commit output from loaders\n let {\n loaderData,\n errors\n } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);\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 // During partial hydration, preserve SSR errors for routes that don't re-run\n if (future.v7_partialHydration && initialHydration && state.errors) {\n Object.entries(state.errors).filter(_ref2 => {\n let [id] = _ref2;\n return !matchesToLoad.some(m => m.route.id === id);\n }).forEach(_ref3 => {\n let [routeId, error] = _ref3;\n errors = Object.assign(errors || {}, {\n [routeId]: error\n });\n });\n }\n let updatedFetchers = markFetchRedirectsDone();\n let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n return _extends({\n matches,\n loaderData,\n errors\n }, shouldUpdateFetchers ? {\n fetchers: new Map(state.fetchers)\n } : {});\n }\n function getUpdatedActionData(pendingActionResult) {\n if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n // This is cast to `any` currently because `RouteData`uses any and it\n // would be a breaking change to use any.\n // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n return {\n [pendingActionResult[0]]: pendingActionResult[1].data\n };\n } else if (state.actionData) {\n if (Object.keys(state.actionData).length === 0) {\n return null;\n } else {\n return state.actionData;\n }\n }\n }\n function getUpdatedRevalidatingFetchers(revalidatingFetchers) {\n revalidatingFetchers.forEach(rf => {\n let fetcher = state.fetchers.get(rf.key);\n let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n state.fetchers.set(rf.key, revalidatingFetcher);\n });\n return new Map(state.fetchers);\n }\n // Trigger a fetcher load/submit for the given fetcher key\n function fetch(key, routeId, href, opts) {\n if (isServer) {\n throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n }\n if (fetchControllers.has(key)) abortFetcher(key);\n let flushSync = (opts && opts.unstable_flushSync) === true;\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n let matches = matchRoutes(routesToUse, normalizedPath, basename);\n let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n if (fogOfWar.active && fogOfWar.matches) {\n matches = fogOfWar.matches;\n }\n if (!matches) {\n setFetcherError(key, routeId, getInternalRouterError(404, {\n pathname: normalizedPath\n }), {\n flushSync\n });\n return;\n }\n let {\n path,\n submission,\n error\n } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n if (error) {\n setFetcherError(key, routeId, error, {\n flushSync\n });\n return;\n }\n let match = getTargetMatch(matches, path);\n pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n if (submission && isMutationMethod(submission.formMethod)) {\n handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);\n return;\n }\n // Store off the match so we can call it's shouldRevalidate on subsequent\n // revalidations\n fetchLoadMatches.set(key, {\n routeId,\n path\n });\n handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);\n }\n // Call the action for the matched fetcher.submit(), and then handle redirects,\n // errors, and revalidation\n async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, submission) {\n interruptActiveLoads();\n fetchLoadMatches.delete(key);\n function detectAndHandle405Error(m) {\n if (!m.route.action && !m.route.lazy) {\n let error = getInternalRouterError(405, {\n method: submission.formMethod,\n pathname: path,\n routeId: routeId\n });\n setFetcherError(key, routeId, error, {\n flushSync\n });\n return true;\n }\n return false;\n }\n if (!isFogOfWar && detectAndHandle405Error(match)) {\n return;\n }\n // Put this fetcher into it's submitting state\n let existingFetcher = state.fetchers.get(key);\n updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n flushSync\n });\n let abortController = new AbortController();\n let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n if (isFogOfWar) {\n let discoverResult = await discoverRoutes(requestMatches, path, fetchRequest.signal);\n if (discoverResult.type === \"aborted\") {\n return;\n } else if (discoverResult.type === \"error\") {\n let {\n error\n } = handleDiscoverRouteError(path, discoverResult);\n setFetcherError(key, routeId, error, {\n flushSync\n });\n return;\n } else if (!discoverResult.matches) {\n setFetcherError(key, routeId, getInternalRouterError(404, {\n pathname: path\n }), {\n flushSync\n });\n return;\n } else {\n requestMatches = discoverResult.matches;\n match = getTargetMatch(requestMatches, path);\n if (detectAndHandle405Error(match)) {\n return;\n }\n }\n }\n // Call the action for the fetcher\n fetchControllers.set(key, abortController);\n let originatingLoadId = incrementingLoadId;\n let actionResults = await callDataStrategy(\"action\", fetchRequest, [match], requestMatches);\n let actionResult = actionResults[0];\n if (fetchRequest.signal.aborted) {\n // We can delete this so long as we weren't aborted by 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 // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n // or redirects processed for unmounted fetchers so we just revert them to\n // idle\n if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n updateFetcherState(key, getDoneFetcher(undefined));\n return;\n }\n // Let SuccessResult's fall through for revalidation\n } else {\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 updateFetcherState(key, getDoneFetcher(undefined));\n return;\n } else {\n fetchRedirectIds.add(key);\n updateFetcherState(key, getLoadingFetcher(submission));\n return startRedirectNavigation(fetchRequest, actionResult, {\n fetcherSubmission: submission\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, {\n 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(init.history, nextLocation, abortController.signal);\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n invariant(matches, \"Didn't find any matches after fetcher action\");\n let loadId = ++incrementingLoadId;\n fetchReloadIds.set(key, loadId);\n let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n state.fetchers.set(key, loadFetcher);\n let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);\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.filter(rf => rf.key !== key).forEach(rf => {\n let staleKey = rf.key;\n let existingFetcher = state.fetchers.get(staleKey);\n let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\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 updateState({\n fetchers: new Map(state.fetchers)\n });\n let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n let {\n loaderResults,\n fetcherResults\n } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n if (abortController.signal.aborted) {\n return;\n }\n abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n fetchReloadIds.delete(key);\n fetchControllers.delete(key);\n revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n let redirect = findRedirect([...loaderResults, ...fetcherResults]);\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 = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n fetchRedirectIds.add(fetcherKey);\n }\n return startRedirectNavigation(revalidationRequest, redirect.result);\n }\n // Process and commit output from loaders\n let {\n loaderData,\n errors\n } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\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 abortStaleFetchLoads(loadId);\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 (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n invariant(pendingAction, \"Expected pending action\");\n pendingNavigationController && pendingNavigationController.abort();\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(state.loaderData, loaderData, matches, errors),\n fetchers: new Map(state.fetchers)\n });\n isRevalidationRequired = false;\n }\n }\n // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, submission) {\n let existingFetcher = state.fetchers.get(key);\n updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n flushSync\n });\n let abortController = new AbortController();\n let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n if (isFogOfWar) {\n let discoverResult = await discoverRoutes(matches, path, fetchRequest.signal);\n if (discoverResult.type === \"aborted\") {\n return;\n } else if (discoverResult.type === \"error\") {\n let {\n error\n } = handleDiscoverRouteError(path, discoverResult);\n setFetcherError(key, routeId, error, {\n flushSync\n });\n return;\n } else if (!discoverResult.matches) {\n setFetcherError(key, routeId, getInternalRouterError(404, {\n pathname: path\n }), {\n flushSync\n });\n return;\n } else {\n matches = discoverResult.matches;\n match = getTargetMatch(matches, path);\n }\n }\n // Call the loader for this fetcher route match\n fetchControllers.set(key, abortController);\n let originatingLoadId = incrementingLoadId;\n let results = await callDataStrategy(\"loader\", fetchRequest, [match], matches);\n let result = results[0];\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 = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\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 if (fetchRequest.signal.aborted) {\n return;\n }\n // We don't want errors bubbling up or redirects followed for unmounted\n // fetchers, so short circuit here if it was removed from the UI\n if (deletedFetchers.has(key)) {\n updateFetcherState(key, getDoneFetcher(undefined));\n return;\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 updateFetcherState(key, getDoneFetcher(undefined));\n return;\n } else {\n fetchRedirectIds.add(key);\n await startRedirectNavigation(fetchRequest, result);\n return;\n }\n }\n // Process any non-redirect errors thrown\n if (isErrorResult(result)) {\n setFetcherError(key, routeId, result.error);\n return;\n }\n invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n // Put the fetcher back into an idle state\n updateFetcherState(key, getDoneFetcher(result.data));\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(request, redirect, _temp2) {\n let {\n submission,\n fetcherSubmission,\n replace\n } = _temp2 === void 0 ? {} : _temp2;\n if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n isRevalidationRequired = true;\n }\n let location = redirect.response.headers.get(\"Location\");\n invariant(location, \"Expected a Location header on the redirect Response\");\n location = normalizeRedirectLocation(location, new URL(request.url), basename);\n let redirectLocation = createLocation(state.location, location, {\n _isRedirect: true\n });\n if (isBrowser) {\n let isDocumentReload = false;\n if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n // Hard reload if the response contained X-Remix-Reload-Document\n isDocumentReload = true;\n } else if (ABSOLUTE_URL_REGEX.test(location)) {\n const url = init.history.createURL(location);\n isDocumentReload =\n // Hard reload if it's an absolute URL to a new origin\n url.origin !== routerWindow.location.origin ||\n // Hard reload if it's an absolute URL that does not match our basename\n stripBasename(url.pathname, basename) == null;\n }\n if (isDocumentReload) {\n if (replace) {\n routerWindow.location.replace(location);\n } else {\n routerWindow.location.assign(location);\n }\n return;\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 let redirectHistoryAction = replace === true || redirect.response.headers.has(\"X-Remix-Replace\") ? Action.Replace : Action.Push;\n // Use the incoming submission if provided, fallback on the active one in\n // state.navigation\n let {\n formMethod,\n formAction,\n formEncType\n } = state.navigation;\n if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\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 let activeSubmission = submission || fetcherSubmission;\n if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n await startNavigation(redirectHistoryAction, redirectLocation, {\n submission: _extends({}, activeSubmission, {\n formAction: location\n }),\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset\n });\n } else {\n // If we have a navigation submission, we will preserve it through the\n // redirect navigation\n let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n await startNavigation(redirectHistoryAction, redirectLocation, {\n overrideNavigation,\n // Send fetcher submissions through for shouldRevalidate\n fetcherSubmission,\n // Preserve this flag across redirects\n preventScrollReset: pendingPreventScrollReset\n });\n }\n }\n // Utility wrapper for calling dataStrategy client-side without having to\n // pass around the manifest, mapRouteProperties, etc.\n async function callDataStrategy(type, request, matchesToLoad, matches) {\n try {\n let results = await callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties);\n return await Promise.all(results.map((result, i) => {\n if (isRedirectHandlerResult(result)) {\n let response = result.result;\n return {\n type: ResultType.redirect,\n response: normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath)\n };\n }\n return convertHandlerResultToDataResult(result);\n }));\n } catch (e) {\n // If the outer dataStrategy method throws, just return the error for all\n // matches - and it'll naturally bubble to the root\n return matchesToLoad.map(() => ({\n type: ResultType.error,\n error: e\n }));\n }\n }\n async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n let [loaderResults, ...fetcherResults] = await Promise.all([matchesToLoad.length ? callDataStrategy(\"loader\", request, matchesToLoad, matches) : [], ...fetchersToLoad.map(f => {\n if (f.matches && f.match && f.controller) {\n let fetcherRequest = createClientSideRequest(init.history, f.path, f.controller.signal);\n return callDataStrategy(\"loader\", fetcherRequest, [f.match], f.matches).then(r => r[0]);\n } else {\n return Promise.resolve({\n type: ResultType.error,\n error: getInternalRouterError(404, {\n pathname: f.path\n })\n });\n }\n })]);\n await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);\n return {\n loaderResults,\n fetcherResults\n };\n }\n function interruptActiveLoads() {\n // Every interruption triggers a revalidation\n isRevalidationRequired = true;\n // Cancel pending route-level deferreds and mark cancelled routes for\n // revalidation\n cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n // Abort in-flight fetcher loads\n fetchLoadMatches.forEach((_, key) => {\n if (fetchControllers.has(key)) {\n cancelledFetcherLoads.add(key);\n abortFetcher(key);\n }\n });\n }\n function updateFetcherState(key, fetcher, opts) {\n if (opts === void 0) {\n opts = {};\n }\n state.fetchers.set(key, fetcher);\n updateState({\n fetchers: new Map(state.fetchers)\n }, {\n flushSync: (opts && opts.flushSync) === true\n });\n }\n function setFetcherError(key, routeId, error, opts) {\n if (opts === void 0) {\n opts = {};\n }\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 flushSync: (opts && opts.flushSync) === true\n });\n }\n function getFetcher(key) {\n if (future.v7_fetcherPersist) {\n activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n // If this fetcher was previously marked for deletion, unmark it since we\n // have a new instance\n if (deletedFetchers.has(key)) {\n deletedFetchers.delete(key);\n }\n }\n return state.fetchers.get(key) || IDLE_FETCHER;\n }\n function deleteFetcher(key) {\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 (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n abortFetcher(key);\n }\n fetchLoadMatches.delete(key);\n fetchReloadIds.delete(key);\n fetchRedirectIds.delete(key);\n deletedFetchers.delete(key);\n cancelledFetcherLoads.delete(key);\n state.fetchers.delete(key);\n }\n function deleteFetcherAndUpdateState(key) {\n if (future.v7_fetcherPersist) {\n let count = (activeFetchers.get(key) || 0) - 1;\n if (count <= 0) {\n activeFetchers.delete(key);\n deletedFetchers.add(key);\n } else {\n activeFetchers.set(key, count);\n }\n } else {\n deleteFetcher(key);\n }\n updateState({\n fetchers: new Map(state.fetchers)\n });\n }\n function abortFetcher(key) {\n let controller = fetchControllers.get(key);\n invariant(controller, \"Expected fetch controller: \" + key);\n controller.abort();\n fetchControllers.delete(key);\n }\n function markFetchersDone(keys) {\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 function markFetchRedirectsDone() {\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 function abortStaleFetchLoads(landedId) {\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 function getBlocker(key, fn) {\n let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n if (blockerFunctions.get(key) !== fn) {\n blockerFunctions.set(key, fn);\n }\n return blocker;\n }\n function deleteBlocker(key) {\n state.blockers.delete(key);\n blockerFunctions.delete(key);\n }\n // Utility function to update blockers, ensuring valid state transitions\n function updateBlocker(key, newBlocker) {\n let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n // Poor mans state machine :)\n // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n let blockers = new Map(state.blockers);\n blockers.set(key, newBlocker);\n updateState({\n blockers\n });\n }\n function shouldBlockNavigation(_ref4) {\n let {\n currentLocation,\n nextLocation,\n historyAction\n } = _ref4;\n if (blockerFunctions.size === 0) {\n return;\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 let entries = Array.from(blockerFunctions.entries());\n let [blockerKey, blockerFunction] = entries[entries.length - 1];\n let blocker = state.blockers.get(blockerKey);\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 // At this point, we know we're unblocked/blocked so we need to check the\n // user-provided blocker function\n if (blockerFunction({\n currentLocation,\n nextLocation,\n historyAction\n })) {\n return blockerKey;\n }\n }\n function handleNavigational404(pathname) {\n let error = getInternalRouterError(404, {\n pathname\n });\n let routesToUse = inFlightDataRoutes || dataRoutes;\n let {\n matches,\n route\n } = getShortCircuitMatches(routesToUse);\n // Cancel all pending deferred on 404s since we don't keep any routes\n cancelActiveDeferreds();\n return {\n notFoundMatches: matches,\n route,\n error\n };\n }\n function handleDiscoverRouteError(pathname, discoverResult) {\n return {\n boundaryId: findNearestBoundary(discoverResult.partialMatches).route.id,\n error: getInternalRouterError(400, {\n type: \"route-discovery\",\n pathname,\n message: discoverResult.error != null && \"message\" in discoverResult.error ? discoverResult.error : String(discoverResult.error)\n })\n };\n }\n function cancelActiveDeferreds(predicate) {\n let cancelledRouteIds = [];\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 // Opt in to capturing and reporting scroll positions during navigations,\n // used by the component\n function enableScrollRestoration(positions, getPosition, getKey) {\n savedScrollPositions = positions;\n getScrollPosition = getPosition;\n getScrollRestorationKey = getKey || null;\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({\n restoreScrollPosition: y\n });\n }\n }\n return () => {\n savedScrollPositions = null;\n getScrollPosition = null;\n getScrollRestorationKey = null;\n };\n }\n function getScrollKey(location, matches) {\n if (getScrollRestorationKey) {\n let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n return key || location.key;\n }\n return location.key;\n }\n function saveScrollPosition(location, matches) {\n if (savedScrollPositions && getScrollPosition) {\n let key = getScrollKey(location, matches);\n savedScrollPositions[key] = getScrollPosition();\n }\n }\n function getSavedScrollPosition(location, matches) {\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 function checkFogOfWar(matches, routesToUse, pathname) {\n if (patchRoutesOnMissImpl) {\n if (!matches) {\n let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n return {\n active: true,\n matches: fogMatches || []\n };\n } else {\n let leafRoute = matches[matches.length - 1].route;\n if (leafRoute.path && (leafRoute.path === \"*\" || leafRoute.path.endsWith(\"/*\"))) {\n // If we matched a splat, it might only be because we haven't yet fetched\n // the children that would match with a higher score, so let's fetch\n // around and find out\n let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n return {\n active: true,\n matches: partialMatches\n };\n }\n }\n }\n return {\n active: false,\n matches: null\n };\n }\n async function discoverRoutes(matches, pathname, signal) {\n let partialMatches = matches;\n let route = partialMatches.length > 0 ? partialMatches[partialMatches.length - 1].route : null;\n while (true) {\n let isNonHMR = inFlightDataRoutes == null;\n let routesToUse = inFlightDataRoutes || dataRoutes;\n try {\n await loadLazyRouteChildren(patchRoutesOnMissImpl, pathname, partialMatches, routesToUse, manifest, mapRouteProperties, pendingPatchRoutes, signal);\n } catch (e) {\n return {\n type: \"error\",\n error: e,\n partialMatches\n };\n } finally {\n // If we are not in the middle of an HMR revalidation and we changed the\n // routes, provide a new identity so when we `updateState` at the end of\n // this navigation/fetch `router.routes` will be a new identity and\n // trigger a re-run of memoized `router.routes` dependencies.\n // HMR will already update the identity and reflow when it lands\n // `inFlightDataRoutes` in `completeNavigation`\n if (isNonHMR) {\n dataRoutes = [...dataRoutes];\n }\n }\n if (signal.aborted) {\n return {\n type: \"aborted\"\n };\n }\n let newMatches = matchRoutes(routesToUse, pathname, basename);\n let matchedSplat = false;\n if (newMatches) {\n let leafRoute = newMatches[newMatches.length - 1].route;\n if (leafRoute.index) {\n // If we found an index route, we can stop\n return {\n type: \"success\",\n matches: newMatches\n };\n }\n if (leafRoute.path && leafRoute.path.length > 0) {\n if (leafRoute.path === \"*\") {\n // If we found a splat route, we can't be sure there's not a\n // higher-scoring route down some partial matches trail so we need\n // to check that out\n matchedSplat = true;\n } else {\n // If we found a non-splat route, we can stop\n return {\n type: \"success\",\n matches: newMatches\n };\n }\n }\n }\n let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n // If we are no longer partially matching anything, this was either a\n // legit splat match above, or it's a 404. Also avoid loops if the\n // second pass results in the same partial matches\n if (!newPartialMatches || partialMatches.map(m => m.route.id).join(\"-\") === newPartialMatches.map(m => m.route.id).join(\"-\")) {\n return {\n type: \"success\",\n matches: matchedSplat ? newMatches : null\n };\n }\n partialMatches = newPartialMatches;\n route = partialMatches[partialMatches.length - 1].route;\n if (route.path === \"*\") {\n // The splat is still our most accurate partial, so run with it\n return {\n type: \"success\",\n matches: partialMatches\n };\n }\n }\n }\n function _internalSetRoutes(newRoutes) {\n manifest = {};\n inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n }\n function patchRoutes(routeId, children) {\n let isNonHMR = inFlightDataRoutes == null;\n let routesToUse = inFlightDataRoutes || dataRoutes;\n patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);\n // If we are not in the middle of an HMR revalidation and we changed the\n // routes, provide a new identity and trigger a reflow via `updateState`\n // to re-run memoized `router.routes` dependencies.\n // HMR will already update the identity and reflow when it lands\n // `inFlightDataRoutes` in `completeNavigation`\n if (isNonHMR) {\n dataRoutes = [...dataRoutes];\n updateState({});\n }\n }\n router = {\n get basename() {\n return basename;\n },\n get future() {\n return future;\n },\n get state() {\n return state;\n },\n get routes() {\n return dataRoutes;\n },\n get window() {\n return routerWindow;\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 => init.history.createHref(to),\n encodeLocation: to => init.history.encodeLocation(to),\n getFetcher,\n deleteFetcher: deleteFetcherAndUpdateState,\n dispose,\n getBlocker,\n deleteBlocker,\n patchRoutes,\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 return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n let manifest = {};\n let basename = (opts ? opts.basename : null) || \"/\";\n let mapRouteProperties;\n if (opts != null && opts.mapRouteProperties) {\n mapRouteProperties = opts.mapRouteProperties;\n } else if (opts != null && 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 // Config driven behavior flags\n let future = _extends({\n v7_relativeSplatPath: false,\n v7_throwAbortReason: false\n }, opts ? opts.future : null);\n let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\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 * - `opts.requestContext` is an optional server context that will be passed\n * to actions/loaders in the `context` parameter\n * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n * the bubbling of errors which allows single-fetch-type implementations\n * where the client will handle the bubbling and we may need to return data\n * for the handling route\n */\n async function query(request, _temp3) {\n let {\n requestContext,\n skipLoaderErrorBubbling,\n unstable_dataStrategy\n } = _temp3 === void 0 ? {} : _temp3;\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 // SSR supports HEAD requests while SPA doesn't\n if (!isValidMethod(method) && method !== \"HEAD\") {\n let error = getInternalRouterError(405, {\n method\n });\n let {\n matches: methodNotAllowedMatches,\n 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, {\n pathname: location.pathname\n });\n let {\n matches: notFoundMatches,\n 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 let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, skipLoaderErrorBubbling === true, null);\n if (isResponse(result)) {\n return result;\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 _extends({\n location,\n basename\n }, result);\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 * - `opts.routeId` allows you to specify the specific route handler to call.\n * If not provided the handler will determine the proper route by matching\n * against `request.url`\n * - `opts.requestContext` is an optional server context that will be passed\n * to actions/loaders in the `context` parameter\n */\n async function queryRoute(request, _temp4) {\n let {\n routeId,\n requestContext,\n unstable_dataStrategy\n } = _temp4 === void 0 ? {} : _temp4;\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 // SSR supports HEAD requests while SPA doesn't\n if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n throw getInternalRouterError(405, {\n method\n });\n } else if (!matches) {\n throw getInternalRouterError(404, {\n pathname: location.pathname\n });\n }\n let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\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, {\n pathname: location.pathname\n });\n }\n let result = await queryImpl(request, location, matches, requestContext, unstable_dataStrategy || null, false, match);\n if (isResponse(result)) {\n return result;\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 // Pick off the right state value to return\n if (result.actionData) {\n return Object.values(result.actionData)[0];\n }\n if (result.loaderData) {\n var _result$activeDeferre;\n let data = Object.values(result.loaderData)[0];\n if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n }\n return data;\n }\n return undefined;\n }\n async function queryImpl(request, location, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch) {\n invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n try {\n if (isMutationMethod(request.method.toLowerCase())) {\n let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch != null);\n return result;\n }\n let result = await loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch);\n return isResponse(result) ? result : _extends({}, result, {\n actionData: null,\n actionHeaders: {}\n });\n } catch (e) {\n // If the user threw/returned a Response in callLoaderOrAction for a\n // `queryRoute` call, we throw the `HandlerResult` to bail out early\n // and then return or throw the raw Response here accordingly\n if (isHandlerResult(e) && isResponse(e.result)) {\n if (e.type === ResultType.error) {\n throw e.result;\n }\n return e.result;\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 async function submit(request, matches, actionMatch, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {\n let result;\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 let results = await callDataStrategy(\"action\", request, [actionMatch], matches, isRouteRequest, requestContext, unstable_dataStrategy);\n result = results[0];\n if (request.signal.aborted) {\n throwStaticHandlerAbortedError(request, isRouteRequest, future);\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.response.status,\n headers: {\n Location: result.response.headers.get(\"Location\")\n }\n });\n }\n if (isDeferredResult(result)) {\n let error = getInternalRouterError(400, {\n type: \"defer-action\"\n });\n if (isRouteRequest) {\n throw error;\n }\n result = {\n type: ResultType.error,\n error\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 return {\n matches: [actionMatch],\n loaderData: {},\n actionData: {\n [actionMatch.route.id]: result.data\n },\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 // 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 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 = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);\n let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);\n // action status codes take precedence over loader status codes\n return _extends({}, context, {\n statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,\n actionData: null,\n actionHeaders: _extends({}, result.headers ? {\n [actionMatch.route.id]: result.headers\n } : {})\n });\n }\n let context = await loadRouteData(loaderRequest, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, null);\n return _extends({}, context, {\n actionData: {\n [actionMatch.route.id]: result.data\n }\n }, result.statusCode ? {\n statusCode: result.statusCode\n } : {}, {\n actionHeaders: result.headers ? {\n [actionMatch.route.id]: result.headers\n } : {}\n });\n }\n async function loadRouteData(request, matches, requestContext, unstable_dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {\n let isRouteRequest = routeMatch != null;\n // Short circuit if we have no loaders to run (queryRoute())\n if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n throw getInternalRouterError(400, {\n method: request.method,\n pathname: new URL(request.url).pathname,\n routeId: routeMatch == null ? void 0 : routeMatch.route.id\n });\n }\n let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;\n let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\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((acc, m) => Object.assign(acc, {\n [m.route.id]: null\n }), {}),\n errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n [pendingActionResult[0]]: pendingActionResult[1].error\n } : null,\n statusCode: 200,\n loaderHeaders: {},\n activeDeferreds: null\n };\n }\n let results = await callDataStrategy(\"loader\", request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy);\n if (request.signal.aborted) {\n throwStaticHandlerAbortedError(request, isRouteRequest, future);\n }\n // Process and commit output from loaders\n let activeDeferreds = new Map();\n let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);\n // Add a null for any non-loader matches for proper revalidation on the client\n let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n matches.forEach(match => {\n if (!executedLoaders.has(match.route.id)) {\n context.loaderData[match.route.id] = null;\n }\n });\n return _extends({}, context, {\n matches,\n activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n });\n }\n // Utility wrapper for calling dataStrategy server-side without having to\n // pass around the manifest, mapRouteProperties, etc.\n async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, unstable_dataStrategy) {\n let results = await callDataStrategyImpl(unstable_dataStrategy || defaultDataStrategy, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext);\n return await Promise.all(results.map((result, i) => {\n if (isRedirectHandlerResult(result)) {\n let response = result.result;\n // Throw redirects and let the server handle them with an HTTP redirect\n throw normalizeRelativeRoutingRedirectResponse(response, request, matchesToLoad[i].route.id, matches, basename, future.v7_relativeSplatPath);\n }\n if (isResponse(result.result) && isRouteRequest) {\n // For SSR single-route requests, we want to hand Responses back\n // directly without unwrapping\n throw result;\n }\n return convertHandlerResultToDataResult(result);\n }));\n }\n return {\n dataRoutes,\n query,\n queryRoute\n };\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\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 */\nfunction getStaticContextFromError(routes, context, error) {\n let newContext = _extends({}, context, {\n statusCode: isRouteErrorResponse(error) ? error.status : 500,\n errors: {\n [context._deepestRenderedBoundaryId || routes[0].id]: error\n }\n });\n return newContext;\n}\nfunction throwStaticHandlerAbortedError(request, isRouteRequest, future) {\n if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n throw request.signal.reason;\n }\n let method = isRouteRequest ? \"queryRoute\" : \"query\";\n throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n}\nfunction isSubmissionNavigation(opts) {\n return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n let contextualMatches;\n let activeRouteMatch;\n if (fromRouteId) {\n // Grab matches up to the calling route so our route-relative logic is\n // relative to the correct source route\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 // Resolve the relative path\n let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\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 // Add an ?index param for matched index routes if we don't already have one\n if ((to == null || to === \"\" || to === \".\") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {\n path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\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 = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n }\n return createPath(path);\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(normalizeFormMethod, isFetcher, path, opts) {\n // Return location verbatim on non-submission navigations\n if (!opts || !isSubmissionNavigation(opts)) {\n return {\n path\n };\n }\n if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n return {\n path,\n error: getInternalRouterError(405, {\n method: opts.formMethod\n })\n };\n }\n let getInvalidBodyError = () => ({\n path,\n error: getInternalRouterError(400, {\n type: \"invalid-body\"\n })\n });\n // Create a Submission on non-GET navigations\n let rawFormMethod = opts.formMethod || \"get\";\n let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n let formAction = stripHashFromPath(path);\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 let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || 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((acc, _ref5) => {\n let [name, value] = _ref5;\n return \"\" + acc + name + \"=\" + value + \"\\n\";\n }, \"\") : String(opts.body);\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 try {\n let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\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 invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n let searchParams;\n let formData;\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 let submission = {\n formMethod,\n formAction,\n formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n formData,\n json: undefined,\n text: undefined\n };\n if (isMutationMethod(submission.formMethod)) {\n return {\n path,\n 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 return {\n path: createPath(parsedPath),\n 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(matches, boundaryId) {\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}\nfunction getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {\n let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;\n let currentUrl = history.createURL(state.location);\n let nextUrl = history.createURL(location);\n // Pick navigation matches that are net-new or qualify for revalidation\n let boundaryId = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[0] : undefined;\n let boundaryMatches = boundaryId ? getLoaderMatchesUntilBoundary(matches, boundaryId) : matches;\n // Don't revalidate loaders by default after action 4xx/5xx responses\n // when the flag is enabled. They can still opt-into revalidation via\n // `shouldRevalidate` via `actionResult`\n let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;\n let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n let navigationMatches = boundaryMatches.filter((match, index) => {\n let {\n route\n } = match;\n if (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 (route.loader == null) {\n return false;\n }\n if (isInitialLoad) {\n if (typeof route.loader !== \"function\" || route.loader.hydrate) {\n return true;\n }\n return state.loaderData[route.id] === undefined && (\n // Don't re-run if the loader ran and threw an error\n !state.errors || state.errors[route.id] === undefined);\n }\n // Always call the loader on new route instances and pending defer cancellations\n if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n return true;\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 return shouldRevalidateLoader(match, _extends({\n currentUrl,\n currentParams: currentRouteMatch.params,\n nextUrl,\n nextParams: nextRouteMatch.params\n }, submission, {\n actionResult,\n actionStatus,\n defaultShouldRevalidate: shouldSkipRevalidation ? false :\n // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n // Search params affect all loaders\n currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n }));\n });\n // Pick fetcher.loads that need to be revalidated\n let revalidatingFetchers = [];\n fetchLoadMatches.forEach((f, key) => {\n // Don't revalidate:\n // - on initial load (shouldn't be any fetchers then anyway)\n // - if fetcher won't be present in the subsequent render\n // - no longer matches the URL (v7_fetcherPersist=false)\n // - was unmounted but persisted due to v7_fetcherPersist=true\n if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n return;\n }\n let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\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 // 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 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.has(key)) {\n // Always mark for revalidation if the fetcher was cancelled\n cancelledFetcherLoads.delete(key);\n shouldRevalidate = true;\n } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\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, _extends({\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 actionStatus,\n defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired\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 return [navigationMatches, revalidatingFetchers];\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n let isNew =\n // [a] -> [a, b]\n !currentMatch ||\n // [a, b] -> [a, c]\n match.route.id !== currentMatch.route.id;\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 // Always load if this is a net-new route or we don't yet have data\n return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\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 && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n if (loaderMatch.route.shouldRevalidate) {\n let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n if (typeof routeChoice === \"boolean\") {\n return routeChoice;\n }\n }\n return arg.defaultShouldRevalidate;\n}\n/**\n * Idempotent utility to execute patchRoutesOnMiss() to lazily load route\n * definitions and update the routes/routeManifest\n */\nasync function loadLazyRouteChildren(patchRoutesOnMissImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {\n let key = [path, ...matches.map(m => m.route.id)].join(\"-\");\n try {\n let pending = pendingRouteChildren.get(key);\n if (!pending) {\n pending = patchRoutesOnMissImpl({\n path,\n matches,\n patch: (routeId, children) => {\n if (!signal.aborted) {\n patchRoutesImpl(routeId, children, routes, manifest, mapRouteProperties);\n }\n }\n });\n pendingRouteChildren.set(key, pending);\n }\n if (pending && isPromise(pending)) {\n await pending;\n }\n } finally {\n pendingRouteChildren.delete(key);\n }\n}\nfunction patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {\n if (routeId) {\n var _route$children;\n let route = manifest[routeId];\n invariant(route, \"No route found to patch children into: routeId = \" + routeId);\n let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, [routeId, \"patch\", String(((_route$children = route.children) == null ? void 0 : _route$children.length) || \"0\")], manifest);\n if (route.children) {\n route.children.push(...dataChildren);\n } else {\n route.children = dataChildren;\n }\n } else {\n let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, [\"patch\", String(routesToUse.length || \"0\")], manifest);\n routesToUse.push(...dataChildren);\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(route, mapRouteProperties, manifest) {\n if (!route.lazy) {\n return;\n }\n let lazyRoute = await route.lazy();\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 let routeToUpdate = manifest[route.id];\n invariant(routeToUpdate, \"No route found in manifest\");\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 = {};\n for (let lazyRouteProperty in lazyRoute) {\n let staticRouteValue = routeToUpdate[lazyRouteProperty];\n let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n // This property isn't static since it should always be updated based\n // on the route updates\n lazyRouteProperty !== \"hasErrorBoundary\";\n warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\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 // 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, _extends({}, mapRouteProperties(routeToUpdate), {\n lazy: undefined\n }));\n}\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nfunction defaultDataStrategy(opts) {\n return Promise.all(opts.matches.map(m => m.resolve()));\n}\nasync function callDataStrategyImpl(dataStrategyImpl, type, request, matchesToLoad, matches, manifest, mapRouteProperties, requestContext) {\n let routeIdsToLoad = matchesToLoad.reduce((acc, m) => acc.add(m.route.id), new Set());\n let loadedMatches = new Set();\n // Send all matches here to allow for a middleware-type implementation.\n // handler will be a no-op for unneeded routes and we filter those results\n // back out below.\n let results = await dataStrategyImpl({\n matches: matches.map(match => {\n let shouldLoad = routeIdsToLoad.has(match.route.id);\n // `resolve` encapsulates the route.lazy, executing the\n // loader/action, and mapping return values/thrown errors to a\n // HandlerResult. Users can pass a callback to take fine-grained control\n // over the execution of the loader/action\n let resolve = handlerOverride => {\n loadedMatches.add(match.route.id);\n return shouldLoad ? callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, requestContext) : Promise.resolve({\n type: ResultType.data,\n result: undefined\n });\n };\n return _extends({}, match, {\n shouldLoad,\n resolve\n });\n }),\n request,\n params: matches[0].params,\n context: requestContext\n });\n // Throw if any loadRoute implementations not called since they are what\n // ensures a route is fully loaded\n matches.forEach(m => invariant(loadedMatches.has(m.route.id), \"`match.resolve()` was not called for route id \\\"\" + m.route.id + \"\\\". \" + \"You must call `match.resolve()` on every match passed to \" + \"`dataStrategy` to ensure all routes are properly loaded.\"));\n // Filter out any middleware-only matches for which we didn't need to run handlers\n return results.filter((_, i) => routeIdsToLoad.has(matches[i].route.id));\n}\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(type, request, match, manifest, mapRouteProperties, handlerOverride, staticContext) {\n let result;\n let onReject;\n let runHandler = handler => {\n // Setup a promise we can race against so that abort signals short circuit\n let reject;\n // This will never resolve so safe to type it as Promise to\n // satisfy the function return value\n let abortPromise = new Promise((_, r) => reject = r);\n onReject = () => reject();\n request.signal.addEventListener(\"abort\", onReject);\n let actualHandler = ctx => {\n if (typeof handler !== \"function\") {\n return Promise.reject(new Error(\"You cannot call the handler for a route which defines a boolean \" + (\"\\\"\" + type + \"\\\" [routeId: \" + match.route.id + \"]\")));\n }\n return handler({\n request,\n params: match.params,\n context: staticContext\n }, ...(ctx !== undefined ? [ctx] : []));\n };\n let handlerPromise;\n if (handlerOverride) {\n handlerPromise = handlerOverride(ctx => actualHandler(ctx));\n } else {\n handlerPromise = (async () => {\n try {\n let val = await actualHandler();\n return {\n type: \"data\",\n result: val\n };\n } catch (e) {\n return {\n type: \"error\",\n result: e\n };\n }\n })();\n }\n return Promise.race([handlerPromise, abortPromise]);\n };\n try {\n let handler = match.route[type];\n if (match.route.lazy) {\n if (handler) {\n // Run statically defined handler in parallel with lazy()\n let handlerError;\n let [value] = await Promise.all([\n // If the handler throws, don't let it immediately bubble out,\n // since we need to let the lazy() execution finish so we know if this\n // route has a boundary that can handle the error\n runHandler(handler).catch(e => {\n handlerError = e;\n }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\n if (handlerError !== undefined) {\n throw handlerError;\n }\n result = value;\n } else {\n // Load lazy route module, then run any returned handler\n await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n handler = match.route[type];\n if (handler) {\n // Handler still runs 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 {\n type: ResultType.data,\n result: undefined\n };\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 invariant(result.result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n } catch (e) {\n // We should already be catching and converting normal handler executions to\n // HandlerResults and returning them, so anything that throws here is an\n // unexpected error we still need to wrap\n return {\n type: ResultType.error,\n result: e\n };\n } finally {\n if (onReject) {\n request.signal.removeEventListener(\"abort\", onReject);\n }\n }\n return result;\n}\nasync function convertHandlerResultToDataResult(handlerResult) {\n let {\n result,\n type\n } = handlerResult;\n if (isResponse(result)) {\n let data;\n try {\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 if (result.body == null) {\n data = null;\n } else {\n data = await result.json();\n }\n } else {\n data = await result.text();\n }\n } catch (e) {\n return {\n type: ResultType.error,\n error: e\n };\n }\n if (type === ResultType.error) {\n return {\n type: ResultType.error,\n error: new ErrorResponseImpl(result.status, result.statusText, data),\n statusCode: result.status,\n headers: result.headers\n };\n }\n return {\n type: ResultType.data,\n data,\n statusCode: result.status,\n headers: result.headers\n };\n }\n if (type === ResultType.error) {\n if (isDataWithResponseInit(result)) {\n var _result$init2;\n if (result.data instanceof Error) {\n var _result$init;\n return {\n type: ResultType.error,\n error: result.data,\n statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status\n };\n }\n // Convert thrown unstable_data() to ErrorResponse instances\n result = new ErrorResponseImpl(((_result$init2 = result.init) == null ? void 0 : _result$init2.status) || 500, undefined, result.data);\n }\n return {\n type: ResultType.error,\n error: result,\n statusCode: isRouteErrorResponse(result) ? result.status : undefined\n };\n }\n if (isDeferredData(result)) {\n var _result$init3, _result$init4;\n return {\n type: ResultType.deferred,\n deferredData: result,\n statusCode: (_result$init3 = result.init) == null ? void 0 : _result$init3.status,\n headers: ((_result$init4 = result.init) == null ? void 0 : _result$init4.headers) && new Headers(result.init.headers)\n };\n }\n if (isDataWithResponseInit(result)) {\n var _result$init5, _result$init6;\n return {\n type: ResultType.data,\n data: result.data,\n statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,\n headers: (_result$init6 = result.init) != null && _result$init6.headers ? new Headers(result.init.headers) : undefined\n };\n }\n return {\n type: ResultType.data,\n data: result\n };\n}\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {\n let location = response.headers.get(\"Location\");\n invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n if (!ABSOLUTE_URL_REGEX.test(location)) {\n let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);\n location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);\n response.headers.set(\"Location\", location);\n }\n return response;\n}\nfunction normalizeRedirectLocation(location, currentUrl, basename) {\n if (ABSOLUTE_URL_REGEX.test(location)) {\n // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n let normalizedLocation = location;\n let url = normalizedLocation.startsWith(\"//\") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);\n let isSameBasename = stripBasename(url.pathname, basename) != null;\n if (url.origin === currentUrl.origin && isSameBasename) {\n return url.pathname + url.search + url.hash;\n }\n }\n return location;\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(history, location, signal, submission) {\n let url = history.createURL(stripHashFromPath(location)).toString();\n let init = {\n signal\n };\n if (submission && isMutationMethod(submission.formMethod)) {\n let {\n formMethod,\n formEncType\n } = 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 if (formEncType === \"application/json\") {\n init.headers = new Headers({\n \"Content-Type\": formEncType\n });\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 (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\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 return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n let searchParams = new URLSearchParams();\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 return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n let formData = new FormData();\n for (let [key, value] of searchParams.entries()) {\n formData.append(key, value);\n }\n return formData;\n}\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {\n // Fill in loaderData/errors from our loaders\n let loaderData = {};\n let errors = null;\n let statusCode;\n let foundError = false;\n let loaderHeaders = {};\n let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;\n // Process loader results into state.loaderData/state.errors\n results.forEach((result, index) => {\n let id = matchesToLoad[index].route.id;\n invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n if (isErrorResult(result)) {\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 !== undefined) {\n error = pendingError;\n pendingError = undefined;\n }\n errors = errors || {};\n if (skipLoaderErrorBubbling) {\n errors[id] = error;\n } else {\n // Look upwards from the matched route for the closest ancestor error\n // boundary, defaulting to the root match. Prefer higher error values\n // if lower errors bubble to the same boundary\n let boundaryMatch = findNearestBoundary(matches, id);\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 // 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) ? result.error.status : 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 // Error status codes always override success status codes, but if all\n // loaders are successful we take the deepest status code.\n if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n statusCode = result.statusCode;\n }\n if (result.headers) {\n loaderHeaders[id] = result.headers;\n }\n } else {\n loaderData[id] = result.data;\n // Error status codes always override success status codes, but if all\n // loaders are successful we take the deepest status code.\n if (result.statusCode && result.statusCode !== 200 && !foundError) {\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 !== undefined && pendingActionResult) {\n errors = {\n [pendingActionResult[0]]: pendingError\n };\n loaderData[pendingActionResult[0]] = undefined;\n }\n return {\n loaderData,\n errors,\n statusCode: statusCode || 200,\n loaderHeaders\n };\n}\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {\n let {\n loaderData,\n errors\n } = processRouteLoaderData(matches, matchesToLoad, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble\n );\n // Process results from our revalidating fetchers\n for (let index = 0; index < revalidatingFetchers.length; index++) {\n let {\n key,\n match,\n controller\n } = revalidatingFetchers[index];\n invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n let result = fetcherResults[index];\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 == null ? void 0 : match.route.id);\n if (!(errors && errors[boundaryMatch.route.id])) {\n errors = _extends({}, 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 return {\n loaderData,\n errors\n };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n let mergedLoaderData = _extends({}, 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 }\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 if (errors && errors.hasOwnProperty(id)) {\n // Don't keep any loader data below the boundary\n break;\n }\n }\n return mergedLoaderData;\n}\nfunction getActionDataForCommit(pendingActionResult) {\n if (!pendingActionResult) {\n return {};\n }\n return isErrorResult(pendingActionResult[1]) ? {\n // Clear out prior actionData on errors\n actionData: {}\n } : {\n actionData: {\n [pendingActionResult[0]]: pendingActionResult[1].data\n }\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(matches, routeId) {\n let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n // Prefer a root layout route if present, otherwise shim in a route object\n let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n id: \"__shim-error-route__\"\n };\n return {\n matches: [{\n params: {},\n pathname: \"\",\n pathnameBase: \"\",\n route\n }],\n route\n };\n}\nfunction getInternalRouterError(status, _temp5) {\n let {\n pathname,\n routeId,\n method,\n type,\n message\n } = _temp5 === void 0 ? {} : _temp5;\n let statusText = \"Unknown Server Error\";\n let errorMessage = \"Unknown @remix-run/router error\";\n if (status === 400) {\n statusText = \"Bad Request\";\n if (type === \"route-discovery\") {\n errorMessage = \"Unable to match URL \\\"\" + pathname + \"\\\" - the `unstable_patchRoutesOnMiss()` \" + (\"function threw the following error:\\n\" + message);\n } else if (method && pathname && routeId) {\n errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"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 = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n } else if (method) {\n errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n }\n }\n return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n for (let i = results.length - 1; i >= 0; i--) {\n let result = results[i];\n if (isRedirectResult(result)) {\n return {\n result,\n idx: i\n };\n }\n }\n}\nfunction stripHashFromPath(path) {\n let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n return createPath(_extends({}, parsedPath, {\n hash: \"\"\n }));\n}\nfunction isHashChangeOnly(a, b) {\n if (a.pathname !== b.pathname || a.search !== b.search) {\n return false;\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 // If the hash is removed the browser will re-perform a request to the server\n // /page#hash -> /page\n return false;\n}\nfunction isPromise(val) {\n return typeof val === \"object\" && val != null && \"then\" in val;\n}\nfunction isHandlerResult(result) {\n return result != null && typeof result === \"object\" && \"type\" in result && \"result\" in result && (result.type === ResultType.data || result.type === ResultType.error);\n}\nfunction isRedirectHandlerResult(result) {\n return isResponse(result.result) && redirectStatusCodes.has(result.result.status);\n}\nfunction isDeferredResult(result) {\n return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n return (result && result.type) === ResultType.redirect;\n}\nfunction isDataWithResponseInit(value) {\n return typeof value === \"object\" && value != null && \"type\" in value && \"data\" in value && \"init\" in value && value.type === \"DataWithResponseInit\";\n}\nfunction isDeferredData(value) {\n let deferred = value;\n return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n if (!isResponse(result)) {\n return false;\n }\n let status = result.status;\n let location = result.headers.get(\"Location\");\n return status >= 300 && status <= 399 && location != null;\n}\nfunction isValidMethod(method) {\n return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {\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 let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\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(signal, \"Expected an AbortSignal for revalidating fetcher deferred result\");\n await resolveDeferredData(result, signal, isFetcher).then(result => {\n if (result) {\n results[index] = result || results[index];\n }\n });\n }\n }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n if (unwrap === void 0) {\n unwrap = false;\n }\n let aborted = await result.deferredData.resolveData(signal);\n if (aborted) {\n return;\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 return {\n type: ResultType.data,\n data: result.deferredData.data\n };\n}\nfunction hasNakedIndexQuery(search) {\n return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\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}\nfunction getSubmissionFromNavigation(navigation) {\n let {\n formMethod,\n formAction,\n formEncType,\n text,\n formData,\n json\n } = navigation;\n if (!formMethod || !formAction || !formEncType) {\n return;\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}\nfunction getLoadingNavigation(location, submission) {\n if (submission) {\n let navigation = {\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 = {\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}\nfunction getSubmittingNavigation(location, submission) {\n let navigation = {\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}\nfunction getLoadingFetcher(submission, data) {\n if (submission) {\n let fetcher = {\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 };\n return fetcher;\n } else {\n let fetcher = {\n state: \"loading\",\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n data\n };\n return fetcher;\n }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n let fetcher = {\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 };\n return fetcher;\n}\nfunction getDoneFetcher(data) {\n let fetcher = {\n state: \"idle\",\n formMethod: undefined,\n formAction: undefined,\n formEncType: undefined,\n formData: undefined,\n json: undefined,\n text: undefined,\n data\n };\n return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n try {\n let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n if (sessionPositions) {\n let json = JSON.parse(sessionPositions);\n for (let [k, v] of Object.entries(json || {})) {\n if (v && Array.isArray(v)) {\n transitions.set(k, new Set(v || []));\n }\n }\n }\n } catch (e) {\n // no-op, use default empty object\n }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n if (transitions.size > 0) {\n let json = {};\n for (let [k, v] of transitions) {\n json[k] = [...v];\n }\n try {\n _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n } catch (error) {\n warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n }\n }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isDataWithResponseInit, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename, data as unstable_data };\n//# sourceMappingURL=router.js.map\n","\"use strict\";\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _Iter_peek;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TokenData = void 0;\nexports.parse = parse;\nexports.compile = compile;\nexports.match = match;\nexports.pathToRegexp = pathToRegexp;\nexports.stringify = stringify;\nconst DEFAULT_DELIMITER = \"/\";\nconst NOOP_VALUE = (value) => value;\nconst ID_START = /^[$_\\p{ID_Start}]$/u;\nconst ID_CONTINUE = /^[$\\u200c\\u200d\\p{ID_Continue}]$/u;\nconst DEBUG_URL = \"https://git.new/pathToRegexpError\";\nconst SIMPLE_TOKENS = {\n // Groups.\n \"{\": \"{\",\n \"}\": \"}\",\n // Reserved.\n \"(\": \"(\",\n \")\": \")\",\n \"[\": \"[\",\n \"]\": \"]\",\n \"+\": \"+\",\n \"?\": \"?\",\n \"!\": \"!\",\n};\n/**\n * Escape text for stringify to path.\n */\nfunction escapeText(str) {\n return str.replace(/[{}()\\[\\]+?!:*]/g, \"\\\\$&\");\n}\n/**\n * Escape a regular expression string.\n */\nfunction escape(str) {\n return str.replace(/[.+*?^${}()[\\]|/\\\\]/g, \"\\\\$&\");\n}\n/**\n * Tokenize input string.\n */\nfunction* lexer(str) {\n const chars = [...str];\n let i = 0;\n function name() {\n let value = \"\";\n if (ID_START.test(chars[++i])) {\n value += chars[i];\n while (ID_CONTINUE.test(chars[++i])) {\n value += chars[i];\n }\n }\n else if (chars[i] === '\"') {\n let pos = i;\n while (i < chars.length) {\n if (chars[++i] === '\"') {\n i++;\n pos = 0;\n break;\n }\n if (chars[i] === \"\\\\\") {\n value += chars[++i];\n }\n else {\n value += chars[i];\n }\n }\n if (pos) {\n throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);\n }\n }\n if (!value) {\n throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);\n }\n return value;\n }\n while (i < chars.length) {\n const value = chars[i];\n const type = SIMPLE_TOKENS[value];\n if (type) {\n yield { type, index: i++, value };\n }\n else if (value === \"\\\\\") {\n yield { type: \"ESCAPED\", index: i++, value: chars[i++] };\n }\n else if (value === \":\") {\n const value = name();\n yield { type: \"PARAM\", index: i, value };\n }\n else if (value === \"*\") {\n const value = name();\n yield { type: \"WILDCARD\", index: i, value };\n }\n else {\n yield { type: \"CHAR\", index: i, value: chars[i++] };\n }\n }\n return { type: \"END\", index: i, value: \"\" };\n}\nclass Iter {\n constructor(tokens) {\n this.tokens = tokens;\n _Iter_peek.set(this, void 0);\n }\n peek() {\n if (!__classPrivateFieldGet(this, _Iter_peek, \"f\")) {\n const next = this.tokens.next();\n __classPrivateFieldSet(this, _Iter_peek, next.value, \"f\");\n }\n return __classPrivateFieldGet(this, _Iter_peek, \"f\");\n }\n tryConsume(type) {\n const token = this.peek();\n if (token.type !== type)\n return;\n __classPrivateFieldSet(this, _Iter_peek, undefined, \"f\"); // Reset after consumed.\n return token.value;\n }\n consume(type) {\n const value = this.tryConsume(type);\n if (value !== undefined)\n return value;\n const { type: nextType, index } = this.peek();\n throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);\n }\n text() {\n let result = \"\";\n let value;\n while ((value = this.tryConsume(\"CHAR\") || this.tryConsume(\"ESCAPED\"))) {\n result += value;\n }\n return result;\n }\n}\n_Iter_peek = new WeakMap();\n/**\n * Tokenized path instance.\n */\nclass TokenData {\n constructor(tokens) {\n this.tokens = tokens;\n }\n}\nexports.TokenData = TokenData;\n/**\n * Parse a string for the raw tokens.\n */\nfunction parse(str, options = {}) {\n const { encodePath = NOOP_VALUE } = options;\n const it = new Iter(lexer(str));\n function consume(endType) {\n const tokens = [];\n while (true) {\n const path = it.text();\n if (path)\n tokens.push({ type: \"text\", value: encodePath(path) });\n const param = it.tryConsume(\"PARAM\");\n if (param) {\n tokens.push({\n type: \"param\",\n name: param,\n });\n continue;\n }\n const wildcard = it.tryConsume(\"WILDCARD\");\n if (wildcard) {\n tokens.push({\n type: \"wildcard\",\n name: wildcard,\n });\n continue;\n }\n const open = it.tryConsume(\"{\");\n if (open) {\n tokens.push({\n type: \"group\",\n tokens: consume(\"}\"),\n });\n continue;\n }\n it.consume(endType);\n return tokens;\n }\n }\n const tokens = consume(\"END\");\n return new TokenData(tokens);\n}\n/**\n * Compile a string to a template function for the path.\n */\nfunction compile(path, options = {}) {\n const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;\n const data = path instanceof TokenData ? path : parse(path, options);\n const fn = tokensToFunction(data.tokens, delimiter, encode);\n return function path(data = {}) {\n const [path, ...missing] = fn(data);\n if (missing.length) {\n throw new TypeError(`Missing parameters: ${missing.join(\", \")}`);\n }\n return path;\n };\n}\nfunction tokensToFunction(tokens, delimiter, encode) {\n const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));\n return (data) => {\n const result = [\"\"];\n for (const encoder of encoders) {\n const [value, ...extras] = encoder(data);\n result[0] += value;\n result.push(...extras);\n }\n return result;\n };\n}\n/**\n * Convert a single token into a path building function.\n */\nfunction tokenToFunction(token, delimiter, encode) {\n if (token.type === \"text\")\n return () => [token.value];\n if (token.type === \"group\") {\n const fn = tokensToFunction(token.tokens, delimiter, encode);\n return (data) => {\n const [value, ...missing] = fn(data);\n if (!missing.length)\n return [value];\n return [\"\"];\n };\n }\n const encodeValue = encode || NOOP_VALUE;\n if (token.type === \"wildcard\" && encode !== false) {\n return (data) => {\n const value = data[token.name];\n if (value == null)\n return [\"\", token.name];\n if (!Array.isArray(value) || value.length === 0) {\n throw new TypeError(`Expected \"${token.name}\" to be a non-empty array`);\n }\n return [\n value\n .map((value, index) => {\n if (typeof value !== \"string\") {\n throw new TypeError(`Expected \"${token.name}/${index}\" to be a string`);\n }\n return encodeValue(value);\n })\n .join(delimiter),\n ];\n };\n }\n return (data) => {\n const value = data[token.name];\n if (value == null)\n return [\"\", token.name];\n if (typeof value !== \"string\") {\n throw new TypeError(`Expected \"${token.name}\" to be a string`);\n }\n return [encodeValue(value)];\n };\n}\n/**\n * Transform a path into a match function.\n */\nfunction match(path, options = {}) {\n const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;\n const { regexp, keys } = pathToRegexp(path, options);\n const decoders = keys.map((key) => {\n if (decode === false)\n return NOOP_VALUE;\n if (key.type === \"param\")\n return decode;\n return (value) => value.split(delimiter).map(decode);\n });\n return function match(input) {\n const m = regexp.exec(input);\n if (!m)\n return false;\n const path = m[0];\n const params = Object.create(null);\n for (let i = 1; i < m.length; i++) {\n if (m[i] === undefined)\n continue;\n const key = keys[i - 1];\n const decoder = decoders[i - 1];\n params[key.name] = decoder(m[i]);\n }\n return { path, params };\n };\n}\nfunction pathToRegexp(path, options = {}) {\n const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;\n const keys = [];\n const sources = [];\n const flags = sensitive ? \"s\" : \"is\";\n const paths = Array.isArray(path) ? path : [path];\n const items = paths.map((path) => path instanceof TokenData ? path : parse(path, options));\n for (const { tokens } of items) {\n for (const seq of flatten(tokens, 0, [])) {\n const regexp = sequenceToRegExp(seq, delimiter, keys);\n sources.push(regexp);\n }\n }\n let pattern = `^(?:${sources.join(\"|\")})`;\n if (trailing)\n pattern += `(?:${escape(delimiter)}$)?`;\n pattern += end ? \"$\" : `(?=${escape(delimiter)}|$)`;\n const regexp = new RegExp(pattern, flags);\n return { regexp, keys };\n}\n/**\n * Generate a flat list of sequence tokens from the given tokens.\n */\nfunction* flatten(tokens, index, init) {\n if (index === tokens.length) {\n return yield init;\n }\n const token = tokens[index];\n if (token.type === \"group\") {\n const fork = init.slice();\n for (const seq of flatten(token.tokens, 0, fork)) {\n yield* flatten(tokens, index + 1, seq);\n }\n }\n else {\n init.push(token);\n }\n yield* flatten(tokens, index + 1, init);\n}\n/**\n * Transform a flat sequence of tokens into a regular expression.\n */\nfunction sequenceToRegExp(tokens, delimiter, keys) {\n let result = \"\";\n let backtrack = \"\";\n let isSafeSegmentParam = true;\n for (let i = 0; i < tokens.length; i++) {\n const token = tokens[i];\n if (token.type === \"text\") {\n result += escape(token.value);\n backtrack = token.value;\n isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));\n continue;\n }\n if (token.type === \"param\" || token.type === \"wildcard\") {\n if (!isSafeSegmentParam && !backtrack) {\n throw new TypeError(`Missing text after \"${token.name}\": ${DEBUG_URL}`);\n }\n if (token.type === \"param\") {\n result += `(${negate(delimiter, isSafeSegmentParam ? \"\" : backtrack)}+)`;\n }\n else {\n result += `(.+)`;\n }\n keys.push(token);\n backtrack = \"\";\n isSafeSegmentParam = false;\n continue;\n }\n }\n return result;\n}\nfunction negate(delimiter, backtrack) {\n const values = [delimiter, backtrack].filter(Boolean);\n const isSimple = values.every((value) => value.length === 1);\n if (isSimple)\n return `[^${escape(values.join(\"\"))}]`;\n return `(?:(?!${values.map(escape).join(\"|\")}).)`;\n}\n/**\n * Stringify token data into a path string.\n */\nfunction stringify(data) {\n return data.tokens\n .map(function stringifyToken(token, index, tokens) {\n if (token.type === \"text\")\n return escapeText(token.value);\n if (token.type === \"group\") {\n return `{${token.tokens.map(stringifyToken).join(\"\")}}`;\n }\n const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);\n const key = isSafe ? token.name : JSON.stringify(token.name);\n if (token.type === \"param\")\n return `:${key}`;\n if (token.type === \"wildcard\")\n return `*${key}`;\n throw new TypeError(`Unexpected token: ${token}`);\n })\n .join(\"\");\n}\nfunction isNameSafe(name) {\n const [first, ...rest] = name;\n if (!ID_START.test(first))\n return false;\n return rest.every((char) => ID_CONTINUE.test(char));\n}\nfunction isNextNameSafe(token) {\n if (token?.type !== \"text\")\n return true;\n return !ID_CONTINUE.test(token.value[0]);\n}\n//# sourceMappingURL=index.js.map","/**\n * React Router DOM v6.26.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { UNSAFE_mapRouteProperties, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, Router, UNSAFE_useRoutesImpl, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, useBlocker } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, IDLE_FETCHER, matchPath } from '@remix-run/router';\nexport { UNSAFE_ErrorResponseImpl } from '@remix-run/router';\n\nfunction _extends() {\n _extends = Object.assign ? Object.assign.bind() : function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n return target;\n };\n return _extends.apply(this, arguments);\n}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n if (source == null) return {};\n var target = {};\n var sourceKeys = Object.keys(source);\n var key, i;\n for (i = 0; i < sourceKeys.length; i++) {\n key = sourceKeys[i];\n if (excluded.indexOf(key) >= 0) continue;\n target[key] = source[key];\n }\n return target;\n}\n\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\nfunction isModifiedEvent(event) {\n return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nfunction shouldProcessLinkClick(event, target) {\n return event.button === 0 && (\n // Ignore everything but left clicks\n !target || target === \"_self\") &&\n // Let browser handle \"target=_blank\" etc.\n !isModifiedEvent(event) // Ignore clicks with modifier keys\n ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n * let searchParams = new URLSearchParams([\n * ['sort', 'name'],\n * ['sort', 'price']\n * ]);\n *\n * you can do:\n *\n * let searchParams = createSearchParams({\n * sort: ['name', 'price']\n * });\n */\nfunction createSearchParams(init) {\n if (init === void 0) {\n init = \"\";\n }\n return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n let value = init[key];\n return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n let searchParams = createSearchParams(locationSearch);\n if (defaultSearchParams) {\n // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n // web extensions. Relevant Bugzilla tickets:\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n defaultSearchParams.forEach((_, key) => {\n if (!searchParams.has(key)) {\n defaultSearchParams.getAll(key).forEach(value => {\n searchParams.append(key, value);\n });\n }\n });\n }\n return searchParams;\n}\n// One-time check for submitter support\nlet _formDataSupportsSubmitter = null;\nfunction isFormDataSubmitterSupported() {\n if (_formDataSupportsSubmitter === null) {\n try {\n new FormData(document.createElement(\"form\"),\n // @ts-expect-error if FormData supports the submitter parameter, this will throw\n 0);\n _formDataSupportsSubmitter = false;\n } catch (e) {\n _formDataSupportsSubmitter = true;\n }\n }\n return _formDataSupportsSubmitter;\n}\nconst supportedFormEncTypes = new Set([\"application/x-www-form-urlencoded\", \"multipart/form-data\", \"text/plain\"]);\nfunction getFormEncType(encType) {\n if (encType != null && !supportedFormEncTypes.has(encType)) {\n process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"\\\"\" + encType + \"\\\" is not a valid `encType` for ``/`` \" + (\"and will default to \\\"\" + defaultEncType + \"\\\"\")) : void 0;\n return null;\n }\n return encType;\n}\nfunction getFormSubmissionInfo(target, basename) {\n let method;\n let action;\n let encType;\n let formData;\n let body;\n if (isFormElement(target)) {\n // When grabbing the action from the element, it will have had the basename\n // prefixed to ensure non-JS scenarios work, so strip it since we'll\n // re-prefix in the router\n let attr = target.getAttribute(\"action\");\n action = attr ? stripBasename(attr, basename) : null;\n method = target.getAttribute(\"method\") || defaultMethod;\n encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n formData = new FormData(target);\n } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n let form = target.form;\n if (form == null) {\n throw new Error(\"Cannot submit a