{"version":3,"file":"react-router.development.js","sources":["../../../../packages/react-router/lib/context.ts","../../../../packages/react-router/lib/router.ts","../../../../packages/react-router/lib/hooks.tsx","../../../../packages/react-router/lib/components.tsx"],"sourcesContent":["import * as React from \"react\";\nimport type { History, Location } from \"history\";\nimport { Action as NavigationType } from \"history\";\n\nimport type { RouteMatch } from \"./router\";\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level <Router> API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport type Navigator = Pick<History, \"go\" | \"push\" | \"replace\" | \"createHref\">;\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\ninterface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n","import type { Location, Path, To } from \"history\";\nimport { parsePath } from \"history\";\n\nexport function invariant(cond: any, message: string): asserts cond {\n  if (!cond) throw new Error(message);\n}\n\nexport function warning(cond: any, message: string): void {\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);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\nexport function warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n\ntype ParamParseFailed = { failed: true };\n\ntype ParamParseSegment<Segment extends string> =\n  // Check here if there exists a forward slash in the string.\n  Segment extends `${infer LeftSegment}/${infer RightSegment}`\n    ? // If there is a forward slash, then attempt to parse each side of the\n      // forward slash.\n      ParamParseSegment<LeftSegment> extends infer LeftResult\n      ? ParamParseSegment<RightSegment> extends infer RightResult\n        ? LeftResult extends string\n          ? // If the left side is successfully parsed as a param, then check if\n            // the right side can be successfully parsed as well. If both sides\n            // can be parsed, then the result is a union of the two sides\n            // (read: \"foo\" | \"bar\").\n            RightResult extends string\n            ? LeftResult | RightResult\n            : LeftResult\n          : // If the left side is not successfully parsed as a param, then check\n          // if only the right side can be successfully parse as a param. If it\n          // can, then the result is just right, else it's a failure.\n          RightResult extends string\n          ? RightResult\n          : ParamParseFailed\n        : ParamParseFailed\n      : // If the left side didn't parse into a param, then just check the right\n      // side.\n      ParamParseSegment<RightSegment> extends infer RightResult\n      ? RightResult extends string\n        ? RightResult\n        : ParamParseFailed\n      : ParamParseFailed\n    : // If there's no forward slash, then check if this segment starts with a\n    // colon. If it does, then this is a dynamic segment, so the result is\n    // just the remainder of the string. Otherwise, it's a failure.\n    Segment extends `:${infer Remaining}`\n    ? Remaining\n    : ParamParseFailed;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\nexport type ParamParseKey<Segment extends string> =\n  ParamParseSegment<Segment> extends string\n    ? ParamParseSegment<Segment>\n    : string;\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params<Key extends string = string> = {\n  readonly [key in Key]: string | undefined;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport interface RouteObject {\n  caseSensitive?: boolean;\n  children?: RouteObject[];\n  element?: React.ReactNode;\n  index?: boolean;\n  path?: string;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nexport function generatePath(path: string, params: Params = {}): string {\n  return path\n    .replace(/:(\\w+)/g, (_, key) => {\n      invariant(params[key] != null, `Missing \":${key}\" param`);\n      return params[key]!;\n    })\n    .replace(/\\/*\\*$/, (_) =>\n      params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\")\n    );\n}\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface RouteMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The route object that was used to match.\n   */\n  route: RouteObject;\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 */\nexport function matchRoutes(\n  routes: RouteObject[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): RouteMatch[] | null {\n  let location =\n    typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], pathname);\n  }\n\n  return matches;\n}\n\ninterface RouteMeta {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObject;\n}\n\ninterface RouteBranch {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes(\n  routes: RouteObject[],\n  branches: RouteBranch[] = [],\n  parentsMeta: RouteMeta[] = [],\n  parentPath = \"\"\n): RouteBranch[] {\n  routes.forEach((route, index) => {\n    let meta: RouteMeta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route,\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(\n        meta.relativePath.startsWith(parentPath),\n        `Absolute route path \"${meta.relativePath}\" nested under path ` +\n          `\"${parentPath}\" is not valid. An absolute child route path ` +\n          `must start with the combined path of all its parent routes.`\n      );\n\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n\n    // Add the children before adding this route to the array so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\n      );\n\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({ path, score: computeScore(path, route.index), routesMeta });\n  });\n\n  return branches;\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n  branches.sort((a, b) =>\n    a.score !== b.score\n      ? b.score - a.score // Higher score first\n      : compareIndexes(\n          a.routesMeta.map((meta) => meta.childrenIndex),\n          b.routesMeta.map((meta) => meta.childrenIndex)\n        )\n  );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments\n    .filter((s) => !isSplat(s))\n    .reduce(\n      (score, segment) =>\n        score +\n        (paramRe.test(segment)\n          ? dynamicSegmentValue\n          : segment === \"\"\n          ? emptySegmentValue\n          : staticSegmentValue),\n      initialScore\n    );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n  let siblings =\n    a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n  return siblings\n    ? // If two routes are siblings, we should try to match the earlier sibling\n      // first. This allows people to have fine-grained control over the matching\n      // behavior by simply putting routes with identical paths in the order they\n      // want them tried.\n      a[a.length - 1] - b[b.length - 1]\n    : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n      // so they sort equally.\n      0;\n}\n\nfunction matchRouteBranch<ParamKey extends string = string>(\n  branch: RouteBranch,\n  pathname: string\n): RouteMatch<ParamKey>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: RouteMatch[] = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname =\n      matchedPathname === \"/\"\n        ? pathname\n        : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath(\n      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n      remainingPathname\n    );\n\n    if (!match) return null;\n\n    Object.assign(matchedParams, match.params);\n\n    let route = meta.route;\n\n    matches.push({\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern<Path extends string = string> {\n  /**\n   * A string to match against a URL pathname. May contain `:id`-style segments\n   * to indicate placeholders for dynamic parameters. May also end with `/*` to\n   * indicate matching the rest of the URL pathname.\n   */\n  path: Path;\n  /**\n   * Should be `true` if the static portions of the `path` should be matched in\n   * the same case.\n   */\n  caseSensitive?: boolean;\n  /**\n   * Should be `true` if this pattern should match the entire URL pathname.\n   */\n  end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch<ParamKey extends string = string> {\n  /**\n   * The names and values of dynamic parameters in the URL.\n   */\n  params: Params<ParamKey>;\n  /**\n   * The portion of the URL pathname that was matched.\n   */\n  pathname: string;\n  /**\n   * The portion of the URL pathname that was matched before child routes.\n   */\n  pathnameBase: string;\n  /**\n   * The pattern that was used to match.\n   */\n  pattern: PathPattern;\n}\n\ntype Mutable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nexport function matchPath<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(\n  pattern: PathPattern<Path> | Path,\n  pathname: string\n): PathMatch<ParamKey> | null {\n  if (typeof pattern === \"string\") {\n    pattern = { path: pattern, caseSensitive: false, end: true };\n  }\n\n  let [matcher, paramNames] = compilePath(\n    pattern.path,\n    pattern.caseSensitive,\n    pattern.end\n  );\n\n  let match = pathname.match(matcher);\n  if (!match) return null;\n\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params: Params = paramNames.reduce<Mutable<Params>>(\n    (memo, paramName, index) => {\n      // We need to compute the pathnameBase here using the raw splat value\n      // instead of using params[\"*\"] later because it will be decoded then\n      if (paramName === \"*\") {\n        let splatValue = captureGroups[index] || \"\";\n        pathnameBase = matchedPathname\n          .slice(0, matchedPathname.length - splatValue.length)\n          .replace(/(.)\\/+$/, \"$1\");\n      }\n\n      memo[paramName] = safelyDecodeURIComponent(\n        captureGroups[index] || \"\",\n        paramName\n      );\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, string[]] {\n  warning(\n    path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n    `Route path \"${path}\" will be treated as if it were ` +\n      `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n      `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n      `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n  );\n\n  let paramNames: string[] = [];\n  let regexpSource =\n    \"^\" +\n    path\n      .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n      .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n      .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n      .replace(/:(\\w+)/g, (_: string, paramName: string) => {\n        paramNames.push(paramName);\n        return \"([^\\\\/]+)\";\n      });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else {\n    regexpSource += end\n      ? \"\\\\/*$\" // 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\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(\n      false,\n      `The value for the URL param \"${paramName}\" will not be decoded because` +\n        ` the string \"${value}\" is a malformed URL segment. This is probably` +\n        ` due to a bad percent encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\",\n  } = typeof to === \"string\" ? parsePath(to) : to;\n\n  let pathname = toPathname\n    ? toPathname.startsWith(\"/\")\n      ? toPathname\n      : resolvePathname(toPathname, fromPathname)\n    : fromPathname;\n\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash),\n  };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n\n  relativeSegments.forEach((segment) => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string\n): Path {\n  let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n  let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname;\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 `<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  let from: string;\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(\"/\");\n\n      // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\n    // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from);\n\n  // Ensure the pathname has a trailing slash if the original to value had one.\n  if (\n    toPathname &&\n    toPathname !== \"/\" &&\n    toPathname.endsWith(\"/\") &&\n    !path.pathname.endsWith(\"/\")\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\nexport function getToPathname(to: To): string | undefined {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || (to as Path).pathname === \"\"\n    ? \"/\"\n    : typeof to === \"string\"\n    ? parsePath(to).pathname\n    : to.pathname;\n}\n\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  let nextChar = pathname.charAt(basename.length);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(basename.length) || \"/\";\n}\n\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\nconst normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n","import * as React from \"react\";\nimport type { Location, Path, To } from \"history\";\nimport { Action as NavigationType, parsePath } from \"history\";\n\nimport { LocationContext, NavigationContext, RouteContext } from \"./context\";\nimport type {\n  ParamParseKey,\n  Params,\n  PathMatch,\n  PathPattern,\n  RouteMatch,\n  RouteObject,\n} from \"./router\";\nimport {\n  getToPathname,\n  invariant,\n  joinPaths,\n  matchPath,\n  matchRoutes,\n  resolveTo,\n  warning,\n  warningOnce,\n} from \"./router\";\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 */\nexport function useHref(to: To): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to);\n\n  let joinedPathname = pathname;\n  if (basename !== \"/\") {\n    let toPathname = getToPathname(to);\n    let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n    joinedPathname =\n      pathname === \"/\"\n        ? basename + (endsWithSlash ? \"/\" : \"\")\n        : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/docs/en/v6/api#uselocation\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/docs/en/v6/api#usenavigationtype\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\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 */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, pathname),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\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 */\nexport function useNavigate(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    matches.map((match) => match.pathnameBase)\n  );\n\n  let activeRef = React.useRef(false);\n  React.useEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(\n        activeRef.current,\n        `You should call navigate() in a React.useEffect(), not when ` +\n          `your component is first rendered.`\n      );\n\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname\n      );\n\n      if (basename !== \"/\") {\n        path.pathname = joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state\n      );\n    },\n    [basename, navigator, routePathnamesJson, locationPathname]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useoutlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useparams\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath\n */\nexport function useResolvedPath(to: To): Path {\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    matches.map((match) => match.pathnameBase)\n  );\n\n  return React.useMemo(\n    () => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname),\n    [to, routePathnamesJson, locationPathname]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useroutes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <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(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname =\n    parentPathnameBase === \"/\"\n      ? pathname\n      : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" does not have an element. ` +\n        `This means it will render an <Outlet /> with a null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  return _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([parentPathnameBase, match.pathname]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([parentPathnameBase, match.pathnameBase]),\n        })\n      ),\n    parentMatches\n  );\n}\n\nexport function _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = []\n): React.ReactElement | null {\n  if (matches == null) return null;\n\n  return matches.reduceRight((outlet, match, index) => {\n    return (\n      <RouteContext.Provider\n        children={\n          match.route.element !== undefined ? match.route.element : outlet\n        }\n        value={{\n          outlet,\n          matches: parentMatches.concat(matches.slice(0, index + 1)),\n        }}\n      />\n    );\n  }, null as React.ReactElement | null);\n}\n","import * as React from \"react\";\nimport type { InitialEntry, Location, MemoryHistory, To } from \"history\";\nimport {\n  Action as NavigationType,\n  createMemoryHistory,\n  parsePath,\n} from \"history\";\n\nimport { LocationContext, NavigationContext, Navigator } from \"./context\";\nimport {\n  useInRouterContext,\n  useNavigate,\n  useOutlet,\n  useRoutes,\n  _renderMatches,\n} from \"./hooks\";\nimport type { RouteMatch, RouteObject } from \"./router\";\nimport { invariant, normalizePathname, stripBasename, warning } from \"./router\";\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/api#memoryrouter\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({ initialEntries, initialIndex });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\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 */\nexport function Navigate({ to, replace, state }: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // 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.`\n  );\n\n  warning(\n    !React.useContext(NavigationContext).static,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let navigate = useNavigate();\n  React.useEffect(() => {\n    navigate(to, { replace, state });\n  });\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\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 */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface RouteProps {\n  caseSensitive?: boolean;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  index?: boolean;\n  path?: string;\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: boolean;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  index?: false;\n  path: string;\n}\n\nexport interface LayoutRouteProps {\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n}\n\nexport interface IndexRouteProps {\n  element?: React.ReactNode | null;\n  index: true;\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 */\nexport function Route(\n  _props: PathRouteProps | LayoutRouteProps | IndexRouteProps\n): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\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 */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  let basename = normalizePathname(basenameProp);\n  let navigationContext = React.useMemo(\n    () => ({ basename, navigator, static: staticProp }),\n    [basename, navigator, staticProp]\n  );\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\n  let location = React.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\n  warning(\n    location != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (location == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider\n        children={children}\n        value={{ location, navigationType }}\n      />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\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 */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\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 */\nexport function createRoutesFromChildren(\n  children: React.ReactNode\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element) => {\n    if (!React.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 === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    let route: RouteObject = {\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\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n"],"names":["NavigationContext","React","displayName","LocationContext","RouteContext","outlet","matches","invariant","cond","message","Error","warning","console","warn","e","alreadyWarned","warningOnce","key","generatePath","path","params","replace","_","matchRoutes","routes","locationArg","basename","location","parsePath","pathname","stripBasename","branches","flattenRoutes","rankRouteBranches","i","length","matchRouteBranch","parentsMeta","parentPath","forEach","route","index","meta","relativePath","caseSensitive","childrenIndex","startsWith","slice","joinPaths","routesMeta","concat","children","push","score","computeScore","sort","a","b","compareIndexes","map","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","segments","split","initialScore","some","filter","reduce","segment","test","siblings","every","n","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","Object","assign","pathnameBase","normalizePathname","pattern","matcher","paramNames","compilePath","captureGroups","memo","paramName","splatValue","safelyDecodeURIComponent","endsWith","regexpSource","RegExp","undefined","value","decodeURIComponent","error","resolvePath","to","fromPathname","toPathname","search","hash","resolvePathname","normalizeSearch","normalizeHash","relativeSegments","pop","join","resolveTo","toArg","routePathnames","locationPathname","from","routePathnameIndex","toSegments","shift","getToPathname","toLowerCase","nextChar","charAt","paths","useHref","useInRouterContext","navigator","useResolvedPath","joinedPathname","endsWithSlash","createHref","useLocation","useNavigationType","navigationType","useMatch","useNavigate","routePathnamesJson","JSON","stringify","activeRef","current","navigate","options","go","parse","state","OutletContext","useOutletContext","useOutlet","context","React.createElement","useParams","routeMatch","useRoutes","parentMatches","parentParams","parentPathname","parentPathnameBase","parentRoute","locationFromContext","parsedLocationArg","element","_renderMatches","reduceRight","MemoryRouter","initialEntries","initialIndex","historyRef","createMemoryHistory","history","setState","action","listen","Navigate","static","Outlet","props","Route","_props","Router","basenameProp","locationProp","NavigationType","Pop","staticProp","navigationContext","trailingPathname","Routes","createRoutesFromChildren","type","apply","name","renderMatches"],"mappings":"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"}