{"version":3,"file":"100.fc494a6f5cfcc007.js","sources":["webpack://storefronts/./node_modules/react-router/index.js"],"sourcesContent":["/**\n * React Router v6.3.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 { parsePath, createMemoryHistory, Action } from 'history';\nexport { Action as NavigationType, createPath, parsePath } from 'history';\nimport { createContext, useContext, useMemo, useRef, useEffect, useCallback, createElement, useState, useLayoutEffect, Children, isValidElement, Fragment } from 'react';\n\nconst NavigationContext = /*#__PURE__*/createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\n\nconst LocationContext = /*#__PURE__*/createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\n\nconst RouteContext = /*#__PURE__*/createContext({\n  outlet: null,\n  matches: []\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\n\nfunction invariant(cond, message) {\n  if (!cond) throw new Error(message);\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging React Router!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nconst alreadyWarned = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? warning(false, message) : void 0;\n  }\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nfunction generatePath(path, params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path.replace(/:(\\w+)/g, (_, key) => {\n    !(params[key] != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Missing \\\":\" + key + \"\\\" param\") : invariant(false) : void 0;\n    return params[key];\n  }).replace(/\\/*\\*$/, _ => params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\"));\n}\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchroutes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], pathname);\n  }\n\n  return matches;\n}\n\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n\n  routes.forEach((route, index) => {\n    let meta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      !meta.relativePath.startsWith(parentPath) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"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.\") : invariant(false) : void 0;\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta); // 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\n    if (route.children && route.children.length > 0) {\n      !(route.index !== true) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\")) : invariant(false) : void 0;\n      flattenRoutes(route.children, branches, routesMeta, path);\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\n\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  });\n  return branches;\n}\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}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\n\nconst isSplat = s => s === \"*\";\n\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\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 ? // 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] : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\n\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n\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    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\n\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n\n  let [matcher, paramNames] = 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 = paramNames.reduce((memo, paramName, index) => {\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n\n    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || \"\", paramName);\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\n\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n\n  if (end === void 0) {\n    end = true;\n  }\n\n  process.env.NODE_ENV !== \"production\" ? 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(/\\*$/, \"/*\") + \"\\\".\")) : void 0;\n  let paramNames = [];\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) => {\n    paramNames.push(paramName);\n    return \"([^\\\\/]+)\";\n  });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else {\n    regexpSource += end ? \"\\\\/*$\" // When matching to the end, ignore trailing slashes\n    : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts\n    // parent routes to matching only their own words and nothing more, e.g. parent\n    // route \"/home\" should not match \"/home2\".\n    // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,\n    // but do not consume the character in the matched path so they can match against\n    // nested paths.\n    \"(?:(?=[.~-]|%[0-9A-F]{2})|\\\\b|\\\\/|$)\";\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value, paramName) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    process.env.NODE_ENV !== \"production\" ? warning(false, \"The value for the URL param \\\"\" + paramName + \"\\\" will not be decoded because\" + (\" the string \\\"\" + value + \"\\\" is a malformed URL segment. This is probably\") + (\" due to a bad percent encoding (\" + error + \").\")) : void 0;\n    return value;\n  }\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\n\n\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\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}\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}\n\nfunction resolveTo(toArg, routePathnames, locationPathname) {\n  let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n  let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname; // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` 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\n  let from;\n\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\"); // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    } // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original to value had one.\n\n  if (toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\") && !path.pathname.endsWith(\"/\")) {\n    path.pathname += \"/\";\n  }\n\n  return path;\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}\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  let nextChar = pathname.charAt(basename.length);\n\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(basename.length) || \"/\";\n}\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usehref\n */\n\nfunction useHref(to) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useHref() may be used only in the context of a <Router> component.\") : invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to);\n  let joinedPathname = pathname;\n\n  if (basename !== \"/\") {\n    let toPathname = getToPathname(to);\n    let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n    joinedPathname = pathname === \"/\" ? basename + (endsWithSlash ? \"/\" : \"\") : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext\n */\n\nfunction useInRouterContext() {\n  return useContext(LocationContext) != null;\n}\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/docs/en/v6/api#uselocation\n */\n\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useLocation() may be used only in the context of a <Router> component.\") : invariant(false) : void 0;\n  return useContext(LocationContext).location;\n}\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigationtype\n */\n\nfunction useNavigationType() {\n  return useContext(LocationContext).navigationType;\n}\n/**\n * Returns true if the URL for the given \"to\" value matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usematch\n */\n\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useMatch() may be used only in the context of a <Router> component.\") : invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\n\n/**\n * Returns an imperative method for changing the location. Used by <Link>s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigate\n */\nfunction useNavigate() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useNavigate() may be used only in the context of a <Router> component.\") : invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = useContext(NavigationContext);\n  let {\n    matches\n  } = useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));\n  let activeRef = useRef(false);\n  useEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(activeRef.current, \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\") : void 0;\n    if (!activeRef.current) return;\n\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);\n\n    if (basename !== \"/\") {\n      path.pathname = joinPaths([basename, path.pathname]);\n    }\n\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state);\n  }, [basename, navigator, routePathnamesJson, locationPathname]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/createContext(null);\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext\n */\n\nfunction useOutletContext() {\n  return useContext(OutletContext);\n}\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useoutlet\n */\n\nfunction useOutlet(context) {\n  let outlet = useContext(RouteContext).outlet;\n\n  if (outlet) {\n    return /*#__PURE__*/createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n\n  return outlet;\n}\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useparams\n */\n\nfunction useParams() {\n  let {\n    matches\n  } = useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\n}\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath\n */\n\nfunction useResolvedPath(to) {\n  let {\n    matches\n  } = useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));\n  return useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname), [to, routePathnamesJson, locationPathname]);\n}\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useroutes\n */\n\nfunction useRoutes(routes, locationArg) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useRoutes() may be used only in the context of a <Router> component.\") : invariant(false) : void 0;\n  let {\n    matches: parentMatches\n  } = useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = parentRoute && parentRoute.path || \"\";\n    warningOnce(parentPathname, !parentRoute || parentPath.endsWith(\"*\"), \"You rendered descendant <Routes> (or called `useRoutes()`) at \" + (\"\\\"\" + parentPathname + \"\\\" (under <Route path=\\\"\" + parentPath + \"\\\">) but the \") + \"parent route path has no trailing \\\"*\\\". This means if you navigate \" + \"deeper, the parent won't match anymore and therefore the child \" + \"routes will never render.\\n\\n\" + (\"Please change the parent <Route path=\\\"\" + parentPath + \"\\\"> to <Route \") + (\"path=\\\"\" + (parentPath === \"/\" ? \"*\" : parentPath + \"/*\") + \"\\\">.\"));\n  }\n\n  let locationFromContext = useLocation();\n  let location;\n\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n\n    let parsedLocationArg = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n    !(parentPathnameBase === \"/\" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = parentPathnameBase === \"/\" ? pathname : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(matches == null || matches[matches.length - 1].route.element !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" does not have an element. \" + \"This means it will render an <Outlet /> with a null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n\n  return _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase, match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])\n  })), parentMatches);\n}\nfunction _renderMatches(matches, parentMatches) {\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n\n  if (matches == null) return null;\n  return matches.reduceRight((outlet, match, index) => {\n    return /*#__PURE__*/createElement(RouteContext.Provider, {\n      children: match.route.element !== undefined ? match.route.element : outlet,\n      value: {\n        outlet,\n        matches: parentMatches.concat(matches.slice(0, index + 1))\n      }\n    });\n  }, null);\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/api#memoryrouter\n */\nfunction MemoryRouter(_ref) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex\n  } = _ref;\n  let historyRef = useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = useState({\n    action: history.action,\n    location: history.location\n  });\n  useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/docs/en/v6/api#navigate\n */\nfunction Navigate(_ref2) {\n  let {\n    to,\n    replace,\n    state\n  } = _ref2;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of\n  // the router loaded. We can help them understand how to avoid that.\n  \"<Navigate> may be used only in the context of a <Router> component.\") : invariant(false) : void 0;\n  process.env.NODE_ENV !== \"production\" ? warning(!useContext(NavigationContext).static, \"<Navigate> must not be used on the initial render in a <StaticRouter>. \" + \"This is a no-op, but you should modify your code so the <Navigate> is \" + \"only ever rendered in response to some user interaction or state change.\") : void 0;\n  let navigate = useNavigate();\n  useEffect(() => {\n    navigate(to, {\n      replace,\n      state\n    });\n  });\n  return null;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/api#outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#route\n */\nfunction Route(_props) {\n   process.env.NODE_ENV !== \"production\" ? invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : invariant(false) ;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/docs/en/v6/api#router\n */\nfunction Router(_ref3) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false\n  } = _ref3;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : invariant(false) : void 0;\n  let basename = normalizePathname(basenameProp);\n  let navigationContext = useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp\n  }), [basename, navigator, staticProp]);\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let location = useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      pathname: trailingPathname,\n      search,\n      hash,\n      state,\n      key\n    };\n  }, [basename, pathname, search, hash, state, key]);\n  process.env.NODE_ENV !== \"production\" ? warning(location != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n\n  if (location == null) {\n    return null;\n  }\n\n  return /*#__PURE__*/createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/createElement(LocationContext.Provider, {\n    children: children,\n    value: {\n      location,\n      navigationType\n    }\n  }));\n}\n\n/**\n * A container for a nested tree of <Route> elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#routes\n */\nfunction Routes(_ref4) {\n  let {\n    children,\n    location\n  } = _ref4;\n  return useRoutes(createRoutesFromChildren(children), location);\n} ///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/docs/en/v6/api#createroutesfromchildren\n */\n\nfunction createRoutesFromChildren(children) {\n  let routes = [];\n  Children.forEach(children, element => {\n    if (! /*#__PURE__*/isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    if (element.type === Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children));\n      return;\n    }\n\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : invariant(false) : void 0;\n    let route = {\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      index: element.props.index,\n      path: element.props.path\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children);\n    }\n\n    routes.push(route);\n  });\n  return routes;\n}\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\n\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nexport { MemoryRouter, Navigate, Outlet, Route, Router, Routes, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, createRoutesFromChildren, generatePath, matchPath, matchRoutes, renderMatches, resolvePath, useHref, useInRouterContext, useLocation, useMatch, useNavigate, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRoutes };\n//# sourceMappingURL=index.js.map\n"],"names":["NavigationContext","LocationContext","RouteContext","invariant","cond","message","Error","generatePath","path","params","_","key","matchRoutes","routes","locationArg","basename","pathname","stripBasename","location","branches","flattenRoutes","parentsMeta","parentPath","route","index","meta","joinPaths","routesMeta","segments","initialScore","isSplat","s","score","segment","paramRe","rankRouteBranches","a","b","siblings","n","i","matches","matchRouteBranch","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","Object","normalizePathname","pattern","caseSensitive","paramNames","regexpSource","matcher","paramName","RegExp","undefined","pathnameBase","captureGroups","memo","splatValue","safelyDecodeURIComponent","value","decodeURIComponent","error","resolvePath","to","fromPathname","relativePath","toPathname","search","hash","relativeSegments","normalizeSearch","normalizeHash","resolveTo","toArg","routePathnames","locationPathname","from","routePathnameIndex","toSegments","nextChar","paths","useHref","useInRouterContext","navigator","useResolvedPath","joinedPathname","endsWithSlash","useLocation","useNavigationType","useMatch","useNavigate","routePathnamesJson","JSON","activeRef","options","OutletContext","useOutletContext","useOutlet","context","outlet","useParams","routeMatch","useRoutes","parentMatches","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","_renderMatches","MemoryRouter","_ref","children","initialEntries","initialIndex","historyRef","history","state","setState","Router","Navigate","_ref2","replace","navigate","Outlet","props","Route","_props","_ref3","basenameProp","locationProp","navigationType","staticProp","navigationContext","trailingPathname","Routes","_ref4","createRoutesFromChildren","element","renderMatches"],"mappings":"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"}