@remix-run/router 1.23.2 → 1.23.4

package/dist/router.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.23.2
+ * @remix-run/router v1.23.4
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -9,18 +9,13 @@
  * @license MIT
  */
 function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
     }
-    return target;
-  };
-  return _extends.apply(this, arguments);
+    return n;
+  }, _extends.apply(null, arguments);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -529,6 +524,7 @@ function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
   let branches = flattenRoutes(routes);
   rankRouteBranches(branches);
   let matches = null;
+  let decoded = decodePath(pathname);
   for (let i = 0; matches == null && i < branches.length; ++i) {
     // Incoming pathnames are generally encoded from either window.location
     // or from router.navigate, but we want to match against the unencoded
@@ -536,7 +532,6 @@ function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
     // encoded here but there also shouldn't be anything to decode so this
     // should be a safe operation.  This avoids needing matchRoutes to be
     // history-aware.
-    let decoded = decodePath(pathname);
     matches = matchRouteBranch(branches[i], decoded, allowPartial);
   }
   return matches;
@@ -886,8 +881,6 @@ function stripBasename(pathname, basename) {
   }
   return pathname.slice(startIndex) || "/";
 }
-const ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const isAbsoluteUrl = url => ABSOLUTE_URL_REGEX$1.test(url);
 /**
  * Returns a resolved path object relative to the given pathname.
  *
@@ -904,19 +897,11 @@ function resolvePath(to, fromPathname) {
   } = typeof to === "string" ? parsePath(to) : to;
   let pathname;
   if (toPathname) {
-    if (isAbsoluteUrl(toPathname)) {
-      pathname = toPathname;
+    toPathname = removeDoubleSlashes(toPathname);
+    if (toPathname.startsWith("/")) {
+      pathname = resolvePathname(toPathname.substring(1), "/");
     } else {
-      if (toPathname.includes("//")) {
-        let oldPathname = toPathname;
-        toPathname = toPathname.replace(/\/\/+/g, "/");
-        warning(false, "Pathnames cannot have embedded double slashes - normalizing " + (oldPathname + " -> " + toPathname));
-      }
-      if (toPathname.startsWith("/")) {
-        pathname = resolvePathname(toPathname.substring(1), "/");
-      } else {
-        pathname = resolvePathname(toPathname, fromPathname);
-      }
+      pathname = resolvePathname(toPathname, fromPathname);
     }
   } else {
     pathname = fromPathname;
@@ -1044,10 +1029,11 @@ function getToPathname(to) {
   // Empty strings should be treated the same as / paths
   return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
 }
+const removeDoubleSlashes = path => path.replace(/\/\/+/g, "/");
 /**
  * @private
  */
-const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+const joinPaths = paths => removeDoubleSlashes(paths.join("/"));
 /**
  * @private
  */
@@ -4449,7 +4435,7 @@ function normalizeRedirectLocation(location, currentUrl, basename, historyInstan
     }
     let isSameBasename = stripBasename(url.pathname, basename) != null;
     if (url.origin === currentUrl.origin && isSameBasename) {
-      return url.pathname + url.search + url.hash;
+      return removeDoubleSlashes(url.pathname) + url.search + url.hash;
     }
   }
   try {