UNPKG

react-router/index.js

Version:
33.5 kBJavaScriptView Raw
1/**
* React Router v6.3.0
*
* Copyright (c) Remix Software Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE.md file in the root directory of this source tree.
*
* @license MIT
*/
11import { parsePath, createMemoryHistory, Action } from 'history';
12export { Action as NavigationType, createPath, parsePath } from 'history';
13import { createContext, useContext, useMemo, useRef, useEffect, useCallback, createElement, useState, useLayoutEffect, Children, isValidElement, Fragment } from 'react';
14
15const NavigationContext = /*#__PURE__*/createContext(null);
16
17if (process.env.NODE_ENV !== "production") {
NavigationContext.displayName = "Navigation";
19}
20
21const LocationContext = /*#__PURE__*/createContext(null);
22
23if (process.env.NODE_ENV !== "production") {
LocationContext.displayName = "Location";
25}
26
27const RouteContext = /*#__PURE__*/createContext({
outlet: null,
matches: []
30});
31
32if (process.env.NODE_ENV !== "production") {
RouteContext.displayName = "Route";
34}
35
36function invariant(cond, message) {
if (!cond) throw new Error(message);
38}
39function warning(cond, message) {
if (!cond) {
  // eslint-disable-next-line no-console
  if (typeof console !== "undefined") console.warn(message);
43
  try {
    // Welcome to debugging React Router!
    //
    // This error is thrown as a convenience so you can more easily
    // find the source for a warning that appears in the console by
    // enabling "pause on exceptions" in your JavaScript debugger.
    throw new Error(message); // eslint-disable-next-line no-empty
  } catch (e) {}
}
53}
54const alreadyWarned = {};
55function warningOnce(key, cond, message) {
if (!cond && !alreadyWarned[key]) {
  alreadyWarned[key] = true;
  process.env.NODE_ENV !== "production" ? warning(false, message) : void 0;
}
60}
61
62/**
* Returns a path with params interpolated.
*
* @see https://reactrouter.com/docs/en/v6/api#generatepath
*/
67function generatePath(path, params) {
if (params === void 0) {
  params = {};
}
71
return path.replace(/:(\w+)/g, (_, key) => {
  !(params[key] != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Missing \":" + key + "\" param") : invariant(false) : void 0;
  return params[key];
}).replace(/\/*\*$/, _ => params["*"] == null ? "" : params["*"].replace(/^\/*/, "/"));
76}
77/**
* A RouteMatch contains info about how a route matched a URL.
*/
80
81/**
* Matches the given routes to a location and returns the match data.
*
* @see https://reactrouter.com/docs/en/v6/api#matchroutes
*/
86function matchRoutes(routes, locationArg, basename) {
if (basename === void 0) {
  basename = "/";
}
90
let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
let pathname = stripBasename(location.pathname || "/", basename);
93
if (pathname == null) {
  return null;
}
97
let branches = flattenRoutes(routes);
rankRouteBranches(branches);
let matches = null;
101
for (let i = 0; matches == null && i < branches.length; ++i) {
  matches = matchRouteBranch(branches[i], pathname);
}
105
return matches;
107}
108
109function flattenRoutes(routes, branches, parentsMeta, parentPath) {
if (branches === void 0) {
  branches = [];
}
113
if (parentsMeta === void 0) {
  parentsMeta = [];
}
117
if (parentPath === void 0) {
  parentPath = "";
}
121
routes.forEach((route, index) => {
  let meta = {
    relativePath: route.path || "",
    caseSensitive: route.caseSensitive === true,
    childrenIndex: index,
    route
  };
129
  if (meta.relativePath.startsWith("/")) {
    !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;
    meta.relativePath = meta.relativePath.slice(parentPath.length);
  }
134
  let path = joinPaths([parentPath, meta.relativePath]);
  let routesMeta = parentsMeta.concat(meta); // Add the children before adding this route to the array so we traverse the
  // route tree depth-first and child routes appear before their parents in
  // the "flattened" version.
139
  if (route.children && route.children.length > 0) {
    !(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;
    flattenRoutes(route.children, branches, routesMeta, path);
  } // Routes without a path shouldn't ever match by themselves unless they are
  // index routes, so don't add them to the list of possible branches.
145
146
  if (route.path == null && !route.index) {
    return;
  }
150
  branches.push({
    path,
    score: computeScore(path, route.index),
    routesMeta
  });
});
return branches;
158}
159
160function rankRouteBranches(branches) {
branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
: compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
163}
164
165const paramRe = /^:\w+$/;
166const dynamicSegmentValue = 3;
167const indexRouteValue = 2;
168const emptySegmentValue = 1;
169const staticSegmentValue = 10;
170const splatPenalty = -2;
171
172const isSplat = s => s === "*";
173
174function computeScore(path, index) {
let segments = path.split("/");
let initialScore = segments.length;
177
if (segments.some(isSplat)) {
  initialScore += splatPenalty;
}
181
if (index) {
  initialScore += indexRouteValue;
}
185
return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
187}
188
189function compareIndexes(a, b) {
let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
return siblings ? // If two routes are siblings, we should try to match the earlier sibling
// first. This allows people to have fine-grained control over the matching
// behavior by simply putting routes with identical paths in the order they
// want them tried.
a[a.length - 1] - b[b.length - 1] : // Otherwise, it doesn't really make sense to rank non-siblings by index,
// so they sort equally.
0;
198}
199
200function matchRouteBranch(branch, pathname) {
let {
  routesMeta
} = branch;
let matchedParams = {};
let matchedPathname = "/";
let matches = [];
207
for (let i = 0; i < routesMeta.length; ++i) {
  let meta = routesMeta[i];
  let end = i === routesMeta.length - 1;
  let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
  let match = matchPath({
    path: meta.relativePath,
    caseSensitive: meta.caseSensitive,
    end
  }, remainingPathname);
  if (!match) return null;
  Object.assign(matchedParams, match.params);
  let route = meta.route;
  matches.push({
    params: matchedParams,
    pathname: joinPaths([matchedPathname, match.pathname]),
    pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
    route
  });
226
  if (match.pathnameBase !== "/") {
    matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
  }
}
231
return matches;
233}
234/**
* A PathPattern is used to match on some portion of a URL pathname.
*/
237
238
239/**
* Performs pattern matching on a URL pathname and returns information about
* the match.
*
* @see https://reactrouter.com/docs/en/v6/api#matchpath
*/
245function matchPath(pattern, pathname) {
if (typeof pattern === "string") {
  pattern = {
    path: pattern,
    caseSensitive: false,
    end: true
  };
}
253
let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
let match = pathname.match(matcher);
if (!match) return null;
let matchedPathname = match[0];
let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
let captureGroups = match.slice(1);
let params = paramNames.reduce((memo, paramName, index) => {
  // We need to compute the pathnameBase here using the raw splat value
  // instead of using params["*"] later because it will be decoded then
  if (paramName === "*") {
    let splatValue = captureGroups[index] || "";
    pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
  }
267
  memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || "", paramName);
  return memo;
}, {});
return {
  params,
  pathname: matchedPathname,
  pathnameBase,
  pattern
};
277}
278
279function compilePath(path, caseSensitive, end) {
if (caseSensitive === void 0) {
  caseSensitive = false;
}
283
if (end === void 0) {
  end = true;
}
287
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;
let paramNames = [];
let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
.replace(/^\/*/, "/") // Make sure it has a leading /
.replace(/[\\.*+^$?{}|()[\]]/g, "\\$&") // Escape special regex chars
.replace(/:(\w+)/g, (_, paramName) => {
  paramNames.push(paramName);
  return "([^\\/]+)";
});
297
if (path.endsWith("*")) {
  paramNames.push("*");
  regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
  : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
} else {
  regexpSource += end ? "\\/*$" // When matching to the end, ignore trailing slashes
  : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts
  // parent routes to matching only their own words and nothing more, e.g. parent
  // route "/home" should not match "/home2".
  // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,
  // but do not consume the character in the matched path so they can match against
  // nested paths.
  "(?:(?=[.~-]|%[0-9A-F]{2})|\\b|\\/|$)";
}
312
let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
return [matcher, paramNames];
315}
316
317function safelyDecodeURIComponent(value, paramName) {
try {
  return decodeURIComponent(value);
} catch (error) {
  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;
  return value;
}
324}
325/**
* Returns a resolved path object relative to the given pathname.
*
* @see https://reactrouter.com/docs/en/v6/api#resolvepath
*/
330
331
332function resolvePath(to, fromPathname) {
if (fromPathname === void 0) {
  fromPathname = "/";
}
336
let {
  pathname: toPathname,
  search = "",
  hash = ""
} = typeof to === "string" ? parsePath(to) : to;
let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
return {
  pathname,
  search: normalizeSearch(search),
  hash: normalizeHash(hash)
};
348}
349
350function resolvePathname(relativePath, fromPathname) {
let segments = fromPathname.replace(/\/+$/, "").split("/");
let relativeSegments = relativePath.split("/");
relativeSegments.forEach(segment => {
  if (segment === "..") {
    // Keep the root "" segment so the pathname starts at /
    if (segments.length > 1) segments.pop();
  } else if (segment !== ".") {
    segments.push(segment);
  }
});
return segments.length > 1 ? segments.join("/") : "/";
362}
363
364function resolveTo(toArg, routePathnames, locationPathname) {
let to = typeof toArg === "string" ? parsePath(toArg) : toArg;
let toPathname = toArg === "" || to.pathname === "" ? "/" : to.pathname; // If a pathname is explicitly provided in `to`, it should be relative to the
// route context. This is explained in `Note on `<Link to>` values` in our
// migration guide from v5 as a means of disambiguation between `to` values
// that begin with `/` and those that do not. However, this is problematic for
// `to` values that do not provide a pathname. `to` can simply be a search or
// hash string, in which case we should assume that the navigation is relative
// to the current location's pathname and *not* the route pathname.
373
let from;
375
if (toPathname == null) {
  from = locationPathname;
} else {
  let routePathnameIndex = routePathnames.length - 1;
380
  if (toPathname.startsWith("..")) {
    let toSegments = toPathname.split("/"); // Each leading .. segment means "go up one route" instead of "go up one
    // URL segment".  This is a key difference from how <a href> works and a
    // major reason we call this a "to" value instead of a "href".
385
    while (toSegments[0] === "..") {
      toSegments.shift();
      routePathnameIndex -= 1;
    }
390
    to.pathname = toSegments.join("/");
  } // If there are more ".." segments than parent routes, resolve relative to
  // the root / URL.
394
395
  from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
}
398
let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original to value had one.
400
if (toPathname && toPathname !== "/" && toPathname.endsWith("/") && !path.pathname.endsWith("/")) {
  path.pathname += "/";
}
404
return path;
406}
407function getToPathname(to) {
// Empty strings should be treated the same as / paths
return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
410}
411function stripBasename(pathname, basename) {
if (basename === "/") return pathname;
413
if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
  return null;
}
417
let nextChar = pathname.charAt(basename.length);
419
if (nextChar && nextChar !== "/") {
  // pathname does not start with basename/
  return null;
}
424
return pathname.slice(basename.length) || "/";
426}
427const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
428const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
429
430const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
431
432const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
433
434/**
* Returns the full href for the given "to" value. This is useful for building
* custom links that are also accessible and preserve right-click behavior.
*
* @see https://reactrouter.com/docs/en/v6/api#usehref
*/
440
441function useHref(to) {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useHref() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
  basename,
  navigator
} = useContext(NavigationContext);
let {
  hash,
  pathname,
  search
} = useResolvedPath(to);
let joinedPathname = pathname;
455
if (basename !== "/") {
  let toPathname = getToPathname(to);
  let endsWithSlash = toPathname != null && toPathname.endsWith("/");
  joinedPathname = pathname === "/" ? basename + (endsWithSlash ? "/" : "") : joinPaths([basename, pathname]);
}
461
return navigator.createHref({
  pathname: joinedPathname,
  search,
  hash
});
467}
468/**
* Returns true if this component is a descendant of a <Router>.
*
* @see https://reactrouter.com/docs/en/v6/api#useinroutercontext
*/
473
474function useInRouterContext() {
return useContext(LocationContext) != null;
476}
477/**
* Returns the current location object, which represents the current URL in web
* browsers.
*
* Note: If you're using this it may mean you're doing some of your own
* "routing" in your app, and we'd like to know what your use case is. We may
* be able to provide something higher-level to better suit your needs.
*
* @see https://reactrouter.com/docs/en/v6/api#uselocation
*/
487
488function useLocation() {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useLocation() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
return useContext(LocationContext).location;
493}
494/**
* Returns the current navigation action which describes how the router came to
* the current location, either by a pop, push, or replace on the history stack.
*
* @see https://reactrouter.com/docs/en/v6/api#usenavigationtype
*/
500
501function useNavigationType() {
return useContext(LocationContext).navigationType;
503}
504/**
* Returns true if the URL for the given "to" value matches the current URL.
* This is useful for components that need to know "active" state, e.g.
* <NavLink>.
*
* @see https://reactrouter.com/docs/en/v6/api#usematch
*/
511
512function useMatch(pattern) {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useMatch() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
  pathname
} = useLocation();
return useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);
520}
521/**
* The interface for the navigate() function returned from useNavigate().
*/
524
525/**
* Returns an imperative method for changing the location. Used by <Link>s, but
* may also be used by other elements to change the location.
*
* @see https://reactrouter.com/docs/en/v6/api#usenavigate
*/
531function useNavigate() {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useNavigate() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
  basename,
  navigator
} = useContext(NavigationContext);
let {
  matches
} = useContext(RouteContext);
let {
  pathname: locationPathname
} = useLocation();
let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));
let activeRef = useRef(false);
useEffect(() => {
  activeRef.current = true;
});
let navigate = useCallback(function (to, options) {
  if (options === void 0) {
    options = {};
  }
554
  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;
  if (!activeRef.current) return;
557
  if (typeof to === "number") {
    navigator.go(to);
    return;
  }
562
  let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);
564
  if (basename !== "/") {
    path.pathname = joinPaths([basename, path.pathname]);
  }
568
  (!!options.replace ? navigator.replace : navigator.push)(path, options.state);
}, [basename, navigator, routePathnamesJson, locationPathname]);
return navigate;
572}
573const OutletContext = /*#__PURE__*/createContext(null);
574/**
* Returns the context (if provided) for the child route at this level of the route
* hierarchy.
* @see https://reactrouter.com/docs/en/v6/api#useoutletcontext
*/
579
580function useOutletContext() {
return useContext(OutletContext);
582}
583/**
* Returns the element for the child route at this level of the route
* hierarchy. Used internally by <Outlet> to render child routes.
*
* @see https://reactrouter.com/docs/en/v6/api#useoutlet
*/
589
590function useOutlet(context) {
let outlet = useContext(RouteContext).outlet;
592
if (outlet) {
  return /*#__PURE__*/createElement(OutletContext.Provider, {
    value: context
  }, outlet);
}
598
return outlet;
600}
601/**
* Returns an object of key/value pairs of the dynamic params from the current
* URL that were matched by the route path.
*
* @see https://reactrouter.com/docs/en/v6/api#useparams
*/
607
608function useParams() {
let {
  matches
} = useContext(RouteContext);
let routeMatch = matches[matches.length - 1];
return routeMatch ? routeMatch.params : {};
614}
615/**
* Resolves the pathname of the given `to` value against the current location.
*
* @see https://reactrouter.com/docs/en/v6/api#useresolvedpath
*/
620
621function useResolvedPath(to) {
let {
  matches
} = useContext(RouteContext);
let {
  pathname: locationPathname
} = useLocation();
let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));
return useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname), [to, routePathnamesJson, locationPathname]);
630}
631/**
* Returns the element of the route that matched the current location, prepared
* with the correct context to render the remainder of the route tree. Route
* elements in the tree must render an <Outlet> to render their child route's
* element.
*
* @see https://reactrouter.com/docs/en/v6/api#useroutes
*/
639
640function useRoutes(routes, locationArg) {
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
// router loaded. We can help them understand how to avoid that.
"useRoutes() may be used only in the context of a <Router> component.") : invariant(false) : void 0;
let {
  matches: parentMatches
} = useContext(RouteContext);
let routeMatch = parentMatches[parentMatches.length - 1];
let parentParams = routeMatch ? routeMatch.params : {};
let parentPathname = routeMatch ? routeMatch.pathname : "/";
let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
let parentRoute = routeMatch && routeMatch.route;
652
if (process.env.NODE_ENV !== "production") {
  // You won't get a warning about 2 different <Routes> under a <Route>
  // without a trailing *, but this is a best-effort warning anyway since we
  // cannot even give the warning unless they land at the parent route.
  //
  // Example:
  //
  // <Routes>
  //   {/* This route path MUST end with /* because otherwise
  //       it will never match /blog/post/123 */}
  //   <Route path="blog" element={<Blog />} />
  //   <Route path="blog/feed" element={<BlogFeed />} />
  // </Routes>
  //
  // function Blog() {
  //   return (
  //     <Routes>
  //       <Route path="post/:id" element={<Post />} />
  //     </Routes>
  //   );
  // }
  let parentPath = parentRoute && parentRoute.path || "";
  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 + "/*") + "\">."));
}
677
let locationFromContext = useLocation();
let location;
680
if (locationArg) {
  var _parsedLocationArg$pa;
683
  let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
  !(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;
  location = parsedLocationArg;
} else {
  location = locationFromContext;
}
690
let pathname = location.pathname || "/";
let remainingPathname = parentPathnameBase === "/" ? pathname : pathname.slice(parentPathnameBase.length) || "/";
let matches = matchRoutes(routes, {
  pathname: remainingPathname
});
696
if (process.env.NODE_ENV !== "production") {
  process.env.NODE_ENV !== "production" ? warning(parentRoute || matches != null, "No routes matched location \"" + location.pathname + location.search + location.hash + "\" ") : void 0;
  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;
}
701
return _renderMatches(matches && matches.map(match => Object.assign({}, match, {
  params: Object.assign({}, parentParams, match.params),
  pathname: joinPaths([parentPathnameBase, match.pathname]),
  pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])
})), parentMatches);
707}
708function _renderMatches(matches, parentMatches) {
if (parentMatches === void 0) {
  parentMatches = [];
}
712
if (matches == null) return null;
return matches.reduceRight((outlet, match, index) => {
  return /*#__PURE__*/createElement(RouteContext.Provider, {
    children: match.route.element !== undefined ? match.route.element : outlet,
    value: {
      outlet,
      matches: parentMatches.concat(matches.slice(0, index + 1))
    }
  });
}, null);
723}
724
725/**
* A <Router> that stores all entries in memory.
*
* @see https://reactrouter.com/docs/en/v6/api#memoryrouter
*/
730function MemoryRouter(_ref) {
let {
  basename,
  children,
  initialEntries,
  initialIndex
} = _ref;
let historyRef = useRef();
738
if (historyRef.current == null) {
  historyRef.current = createMemoryHistory({
    initialEntries,
    initialIndex
  });
}
745
let history = historyRef.current;
let [state, setState] = useState({
  action: history.action,
  location: history.location
});
useLayoutEffect(() => history.listen(setState), [history]);
return /*#__PURE__*/createElement(Router, {
  basename: basename,
  children: children,
  location: state.location,
  navigationType: state.action,
  navigator: history
});
759}
760
761/**
* Changes the current location.
*
* Note: This API is mostly useful in React.Component subclasses that are not
* able to use hooks. In functional components, we recommend you use the
* `useNavigate` hook instead.
*
* @see https://reactrouter.com/docs/en/v6/api#navigate
*/
770function Navigate(_ref2) {
let {
  to,
  replace,
  state
} = _ref2;
!useInRouterContext() ? process.env.NODE_ENV !== "production" ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of
// the router loaded. We can help them understand how to avoid that.
"<Navigate> may be used only in the context of a <Router> component.") : invariant(false) : void 0;
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;
let navigate = useNavigate();
useEffect(() => {
  navigate(to, {
    replace,
    state
  });
});
return null;
788}
789
790/**
* Renders the child route's element, if there is one.
*
* @see https://reactrouter.com/docs/en/v6/api#outlet
*/
795function Outlet(props) {
return useOutlet(props.context);
797}
798
799/**
* Declares an element that should be rendered at a certain URL path.
*
* @see https://reactrouter.com/docs/en/v6/api#route
*/
804function Route(_props) {
 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) ;
806}
807
808/**
* Provides location context for the rest of the app.
*
* Note: You usually won't render a <Router> directly. Instead, you'll render a
* router that is more specific to your environment such as a <BrowserRouter>
* in web browsers or a <StaticRouter> for server rendering.
*
* @see https://reactrouter.com/docs/en/v6/api#router
*/
817function Router(_ref3) {
let {
  basename: basenameProp = "/",
  children = null,
  location: locationProp,
  navigationType = Action.Pop,
  navigator,
  static: staticProp = false
} = _ref3;
!!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;
let basename = normalizePathname(basenameProp);
let navigationContext = useMemo(() => ({
  basename,
  navigator,
  static: staticProp
}), [basename, navigator, staticProp]);
833
if (typeof locationProp === "string") {
  locationProp = parsePath(locationProp);
}
837
let {
  pathname = "/",
  search = "",
  hash = "",
  state = null,
  key = "default"
} = locationProp;
let location = useMemo(() => {
  let trailingPathname = stripBasename(pathname, basename);
847
  if (trailingPathname == null) {
    return null;
  }
851
  return {
    pathname: trailingPathname,
    search,
    hash,
    state,
    key
  };
}, [basename, pathname, search, hash, state, key]);
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;
861
if (location == null) {
  return null;
}
865
return /*#__PURE__*/createElement(NavigationContext.Provider, {
  value: navigationContext
}, /*#__PURE__*/createElement(LocationContext.Provider, {
  children: children,
  value: {
    location,
    navigationType
  }
}));
875}
876
877/**
* A container for a nested tree of <Route> elements that renders the branch
* that best matches the current location.
*
* @see https://reactrouter.com/docs/en/v6/api#routes
*/
883function Routes(_ref4) {
let {
  children,
  location
} = _ref4;
return useRoutes(createRoutesFromChildren(children), location);
889} ///////////////////////////////////////////////////////////////////////////////
890// UTILS
891///////////////////////////////////////////////////////////////////////////////
892
893/**
* Creates a route config from a React "children" object, which is usually
* either a `<Route>` element or an array of them. Used internally by
* `<Routes>` to create a route config from its children.
*
* @see https://reactrouter.com/docs/en/v6/api#createroutesfromchildren
*/
900
901function createRoutesFromChildren(children) {
let routes = [];
Children.forEach(children, element => {
  if (! /*#__PURE__*/isValidElement(element)) {
    // Ignore non-elements. This allows people to more easily inline
    // conditionals in their route config.
    return;
  }
909
  if (element.type === Fragment) {
    // Transparently support React.Fragment and its children.
    routes.push.apply(routes, createRoutesFromChildren(element.props.children));
    return;
  }
915
  !(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;
  let route = {
    caseSensitive: element.props.caseSensitive,
    element: element.props.element,
    index: element.props.index,
    path: element.props.path
  };
923
  if (element.props.children) {
    route.children = createRoutesFromChildren(element.props.children);
  }
927
  routes.push(route);
});
return routes;
931}
932/**
* Renders the result of `matchRoutes()` into a React element.
*/
935
936function renderMatches(matches) {
return _renderMatches(matches);
938}
939
940export { 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 };
941//# sourceMappingURL=index.js.map