@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/shared/lib/router/router.js

@@ -65,11 +65,7 @@ if (process.env.__NEXT_HAS_REWRITES) {
     resolveRewrites = require('./utils/resolve-rewrites').default;
 }
 function buildCancellationError() {
-    return Object.assign(Object.defineProperty(new Error('Route Cancelled'), "__NEXT_ERROR_CODE", {
-        value: "E315",
-        enumerable: false,
-        configurable: true
-    }), {
+    return Object.assign(new Error('Route Cancelled'), {
         cancelled: true
     });
 }
@@ -104,6 +100,44 @@ function prepareUrlAs(router, url, as) {
         as: asWasAbsolute ? preparedAs : (0, _addbasepath.addBasePath)(preparedAs)
     };
 }
+/**
+ * Key under which `prefetch()` stores the `{ __appRouter: true }` marker in
+ * `router.components` and under which `change()` looks it up again.
+ *
+ * The client router filter (`_bfl`) is evaluated against the `as` path, so the
+ * marker has to be keyed by the `as` path as well. Keying it by the `href`
+ * pathname is only equivalent while `href` and `as` are the same URL. When
+ * they differ (for example the "route as modal" pattern where `href` stays on
+ * the current page and `as` shows a pretty URL) a filter match on `as` would
+ * otherwise mark the pages route behind `href` as an App Router path and
+ * break every later navigation to that route.
+ *
+ * `as` is expected without the `basePath`, which is what both call sites
+ * hold: `prefetch()` receives it that way from `next/link` and `change()`
+ * strips it before computing `cleanedAs`. Stripping it again here would turn
+ * a route that merely starts with the `basePath` (for example the app route
+ * `/docs` with `basePath: '/docs'`) into `/` and poison the index page.
+ *
+ * The key also carries the effective locale, mirroring how `_bfl` evaluates
+ * `addLocale(as, locale)` against the filter. A match for a French-only
+ * redirect at `/fr/legacy` must not mark the English `/legacy` page.
+ *
+ * Returns `null` when `as` is not a local URL (for example `mailto:` or a
+ * different origin). Such an `as` can never be an App Router path, and
+ * `change()` reports it as an invalid `href`/`as` pair further down.
+ */ function getAppRouterMarkerKey(router, as, locale) {
+    if (!(0, _islocalurl.isLocalURL)(as)) {
+        return null;
+    }
+    let { pathname } = (0, _parserelativeurl.parseRelativeUrl)(as);
+    let effectiveLocale = locale || router.locale;
+    if (process.env.__NEXT_I18N_SUPPORT) {
+        const localePathResult = (0, _normalizelocalepath.normalizeLocalePath)(pathname, router.locales);
+        pathname = localePathResult.pathname;
+        effectiveLocale = localePathResult.detectedLocale || effectiveLocale;
+    }
+    return (0, _removetrailingslash.removeTrailingSlash)((0, _addlocale.addLocale)((0, _removetrailingslash.removeTrailingSlash)(pathname), effectiveLocale));
+}
 function resolveDynamicRoute(pathname, pages) {
     const cleanPathname = (0, _removetrailingslash.removeTrailingSlash)((0, _denormalizepagepath.denormalizePagePath)(pathname));
     if (cleanPathname === '/404' || cleanPathname === '/_error') {
@@ -338,11 +372,7 @@ function fetchNextData({ dataHref, inflightCache, isPrefetch, hasMiddleware, isS
                             };
                         }
                     }
-                    const error = Object.defineProperty(new Error(`Failed to load static props`), "__NEXT_ERROR_CODE", {
-                        value: "E124",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    const error = new Error(`Failed to load static props`);
                     /**
              * We should only trigger a server-side transition if this was
              * caused on a client-side transition. Otherwise, we'd get into
@@ -355,11 +385,7 @@ function fetchNextData({ dataHref, inflightCache, isPrefetch, hasMiddleware, isS
                 let dplResponseHeader = response.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER);
                 if (dplResponseHeader != null && dplResponseHeader !== deploymentId) {
                     // When not found, or we want to force a MPA navigation because of Skew Protection
-                    const error = Object.defineProperty(new Error(`Loaded static props were from an outdated deployment, forcing a hard reload`), "__NEXT_ERROR_CODE", {
-                        value: "E989",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    const error = new Error(`Loaded static props were from an outdated deployment, forcing a hard reload`);
                     /**
              * We should only trigger a server-side transition if this was
              * caused on a client-side transition. Otherwise, we'd get into
@@ -421,11 +447,7 @@ function handleHardNavigation({ url, router }) {
     // ensure we don't trigger a hard navigation to the same
     // URL as this can end up with an infinite refresh
     if (url === (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(router.asPath, router.locale))) {
-        throw Object.defineProperty(new Error(`Invariant: attempted to hard navigate to the same URL ${url} ${location.href}`), "__NEXT_ERROR_CODE", {
-            value: "E282",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: attempted to hard navigate to the same URL ${url} ${location.href}`);
     }
     window.location.href = url;
 }
@@ -436,11 +458,7 @@ const getCancelledHandler = ({ route, router })=>{
     };
     const handleCancelled = ()=>{
         if (cancelled) {
-            const error = Object.defineProperty(new Error(`Abort fetching component for route: "${route}"`), "__NEXT_ERROR_CODE", {
-                value: "E483",
-                enumerable: false,
-                configurable: true
-            });
+            const error = new Error(`Abort fetching component for route: "${route}"`);
             error.cancelled = true;
             throw error;
         }
@@ -647,11 +665,7 @@ class Router {
    * @param options object you can define `shallow` and other options
    */ push(url, as, options = {}) {
         if ((0, _javascripturl.isJavaScriptURLString)(url.toString()) || as && (0, _javascripturl.isJavaScriptURLString)(as.toString())) {
-            throw Object.defineProperty(new Error('Next.js has blocked a javascript: URL as a security precaution.'), "__NEXT_ERROR_CODE", {
-                value: "E978",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Next.js has blocked a javascript: URL as a security precaution.');
         }
         if (process.env.__NEXT_SCROLL_RESTORATION) {
             // TODO: remove in the future when we update history before route change
@@ -677,11 +691,7 @@ class Router {
    * @param options object you can define `shallow` and other options
    */ replace(url, as, options = {}) {
         if ((0, _javascripturl.isJavaScriptURLString)(url.toString()) || as && (0, _javascripturl.isJavaScriptURLString)(as.toString())) {
-            throw Object.defineProperty(new Error('Next.js has blocked a javascript: URL as a security precaution.'), "__NEXT_ERROR_CODE", {
-                value: "E978",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Next.js has blocked a javascript: URL as a security precaution.');
         }
         ;
         ({ url, as } = prepareUrlAs(this, url, as));
@@ -941,9 +951,13 @@ class Router {
         pathname = pathname ? (0, _removetrailingslash.removeTrailingSlash)((0, _removebasepath.removeBasePath)(pathname)) : pathname;
         let route = (0, _removetrailingslash.removeTrailingSlash)(pathname);
         const parsedAsPathname = as.startsWith('/') && (0, _parserelativeurl.parseRelativeUrl)(as).pathname;
-        // if we detected the path as app route during prefetching
-        // trigger hard navigation
-        if (this.components[pathname]?.__appRouter) {
+        // if we detected the `as` path as app route during prefetching
+        // trigger hard navigation. The marker is keyed by the `as` path, but a
+        // marker can also sit under the href route when both paths share a
+        // pages route (`pages/modal.js` next to `app/modal/[id]/page.js`).
+        // Check both so `getRouteInfo()` never reads a marker as component data.
+        const appRouterMarkerKey = getAppRouterMarkerKey(this, cleanedAs, nextState.locale);
+        if (appRouterMarkerKey !== null && this.components[appRouterMarkerKey]?.__appRouter || this.components[route]?.__appRouter) {
             handleHardNavigation({
                 url: as,
                 router: this
@@ -1017,11 +1031,7 @@ class Router {
         }
         if (!(0, _islocalurl.isLocalURL)(as)) {
             if (process.env.NODE_ENV !== 'production') {
-                throw Object.defineProperty(new Error(`Invalid href: "${url}" and as: "${as}", received relative href and external as` + `\nSee more info: https://nextjs.org/docs/messages/invalid-relative-url-external-as`), "__NEXT_ERROR_CODE", {
-                    value: "E380",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid href: "${url}" and as: "${as}", received relative href and external as` + `\nSee more info: https://nextjs.org/docs/messages/invalid-relative-url-external-as`);
             }
             handleHardNavigation({
                 url: as,
@@ -1031,6 +1041,16 @@ class Router {
         }
         resolvedAs = (0, _removelocale.removeLocale)((0, _removebasepath.removeBasePath)(resolvedAs), nextState.locale);
         route = (0, _removetrailingslash.removeTrailingSlash)(pathname);
+        // A config rewrite can resolve `href` to another pages route after the
+        // marker guard above ran. That route can hold a marker from an earlier
+        // prefetch, so check it again before `getRouteInfo()` reads the cache.
+        if (this.components[route]?.__appRouter) {
+            handleHardNavigation({
+                url: as,
+                router: this
+            });
+            return new Promise(()=>{});
+        }
         let routeMatch = false;
         if ((0, _isdynamic.isDynamicRoute)(route)) {
             const parsedAs = (0, _parserelativeurl.parseRelativeUrl)(resolvedAs);
@@ -1045,11 +1065,7 @@ class Router {
                     if (process.env.NODE_ENV !== 'production') {
                         console.warn(`${shouldInterpolate ? `Interpolating href` : `Mismatching \`as\` and \`href\``} failed to manually provide ` + `the params: ${missingParams.join(', ')} in the \`href\`'s \`query\``);
                     }
-                    throw Object.defineProperty(new Error((shouldInterpolate ? `The provided \`href\` (${url}) value is missing query values (${missingParams.join(', ')}) to be interpolated properly. ` : `The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${route}). `) + `Read more: https://nextjs.org/docs/messages/${shouldInterpolate ? 'href-interpolation-failed' : 'incompatible-href-as'}`), "__NEXT_ERROR_CODE", {
-                        value: "E344",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error((shouldInterpolate ? `The provided \`href\` (${url}) value is missing query values (${missingParams.join(', ')}) to be interpolated properly. ` : `The provided \`as\` value (${asPathname}) is incompatible with the \`href\` value (${route}). `) + `Read more: https://nextjs.org/docs/messages/${shouldInterpolate ? 'href-interpolation-failed' : 'incompatible-href-as'}`);
                 }
             } else if (shouldInterpolate) {
                 as = (0, _formaturl.formatWithValidation)(Object.assign({}, parsedAs, {
@@ -1179,11 +1195,7 @@ class Router {
                         isNotFound: true
                     });
                     if ('type' in routeInfo) {
-                        throw Object.defineProperty(new Error(`Unexpected middleware effect on /404`), "__NEXT_ERROR_CODE", {
-                            value: "E158",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error(`Unexpected middleware effect on /404`);
                     }
                 }
             }
@@ -1229,11 +1241,7 @@ class Router {
                     isQueryUpdating: isQueryUpdating && !this.isFallback
                 });
                 if ('type' in routeInfo) {
-                    throw Object.defineProperty(new Error(`Unexpected middleware effect on ${this.pathname}`), "__NEXT_ERROR_CODE", {
-                        value: "E225",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Unexpected middleware effect on ${this.pathname}`);
                 }
                 if (this.pathname === '/_error' && self.__NEXT_DATA__.props?.pageProps?.statusCode === 500 && routeInfo.props?.pageProps) {
                     // ensure statusCode is still correct for static 500 page
@@ -1361,11 +1369,7 @@ class Router {
             }
             return routeInfo;
         } catch (routeInfoErr) {
-            return this.handleRouteInfoError((0, _iserror.default)(routeInfoErr) ? routeInfoErr : Object.defineProperty(new Error(routeInfoErr + ''), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            }), pathname, query, as, routeProps, true);
+            return this.handleRouteInfoError((0, _iserror.default)(routeInfoErr) ? routeInfoErr : new Error(routeInfoErr + ''), pathname, query, as, routeProps, true);
         }
     }
     async getRouteInfo({ route: requestedRoute, pathname, query, as, resolvedAs, routeProps, locale, hasMiddleware, isPreview, unstable_skipClientCache, isQueryUpdating, isMiddlewareRewrite, isNotFound }) {
@@ -1377,6 +1381,14 @@ class Router {
      */ let route = requestedRoute;
         try {
             let existingInfo = this.components[route];
+            // `prefetch()` stores a `{ __appRouter: true }` marker in
+            // `this.components` when the client router filter matches a path. That
+            // marker is not route info: it has no `Component` and no `props`, so
+            // rendering it crashes `_app`. Treat it as a cache miss and fetch the
+            // route info again; `change()` is responsible for the hard navigation.
+            if (existingInfo && existingInfo.__appRouter) {
+                existingInfo = undefined;
+            }
             if (routeProps.shallow && existingInfo && this.route === route) {
                 return existingInfo;
             }
@@ -1458,6 +1470,9 @@ class Router {
                     resolvedAs = (0, _removebasepath.removeBasePath)((0, _normalizelocalepath.normalizeLocalePath)(data.effect.parsedAs.pathname, this.locales).pathname);
                     // Check again the cache with the new destination.
                     existingInfo = this.components[route];
+                    if (existingInfo && existingInfo.__appRouter) {
+                        existingInfo = undefined;
+                    }
                     if (routeProps.shallow && existingInfo && this.route === route && !hasMiddleware) {
                         // If we have a match with the current route due to rewrite,
                         // we can copy the existing information to the rewritten one.
@@ -1485,11 +1500,7 @@ class Router {
             if (process.env.NODE_ENV !== 'production') {
                 const { isValidElementType } = require('next/dist/compiled/react-is');
                 if (!isValidElementType(routeInfo.Component)) {
-                    throw Object.defineProperty(new Error(`The default export is not a React Component in page: "${pathname}"`), "__NEXT_ERROR_CODE", {
-                        value: "E286",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`The default export is not a React Component in page: "${pathname}"`);
                 }
             }
             const wasBailedPrefetch = data?.response?.headers.get('x-middleware-skip');
@@ -1643,7 +1654,6 @@ class Router {
             return;
         }
         let parsed = (0, _parserelativeurl.parseRelativeUrl)(url);
-        const urlPathname = parsed.pathname;
         let { pathname, query } = parsed;
         const originalPathname = pathname;
         if (process.env.__NEXT_I18N_SUPPORT) {
@@ -1738,9 +1748,21 @@ class Router {
         }
         const route = (0, _removetrailingslash.removeTrailingSlash)(pathname);
         if (await this._bfl(asPath, resolvedAs, options.locale, true)) {
-            this.components[urlPathname] = {
-                __appRouter: true
-            };
+            const appRouterMarkerKey = getAppRouterMarkerKey(this, asPath, options.locale);
+            // A loaded pages route in the cache is ground truth: the page behind
+            // this key exists and was rendered. This is the case when the current
+            // page was reached through a rewrite and the canonical URL is
+            // prefetched, or when a prefetch is still in flight while a navigation
+            // stores the same route. Replacing that entry with the marker would
+            // break hash-only changes and shallow navigations, which render the
+            // cached entry of the current route directly. Non-shallow navigations
+            // consult the client router filter themselves, so they do not depend
+            // on the marker to hard navigate.
+            if (appRouterMarkerKey !== null && this.components[appRouterMarkerKey] === undefined) {
+                this.components[appRouterMarkerKey] = {
+                    __appRouter: true
+                };
+            }
         }
         await Promise.all([
             this.pageLoader._isSsg(route).then((isSsg)=>{
@@ -1786,11 +1808,7 @@ class Router {
                 this.clc = null;
             }
             if (cancelled) {
-                const err = Object.defineProperty(new Error('Loading initial props cancelled'), "__NEXT_ERROR_CODE", {
-                    value: "E405",
-                    enumerable: false,
-                    configurable: true
-                });
+                const err = new Error('Loading initial props cancelled');
                 err.cancelled = true;
                 throw err;
             }

package/app/node_modules/next/dist/shared/lib/router/routes/app.js

@@ -109,28 +109,16 @@ function parseAppRouteImpl(pathname, allowedTypes) {
             continue;
         }
         if (appSegment.type === 'route-group' && !(allowedTypes & AllowGroupSegments)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group segment.`), "__NEXT_ERROR_CODE", {
-                value: "E1151",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a route group segment.`);
         }
         if (appSegment.type === 'parallel-route' && !(allowedTypes & AllowParallelSegments)) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a parallel route segment.`), "__NEXT_ERROR_CODE", {
-                value: "E1152",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`${pathname} is being parsed as a normalized route, but it has a parallel route segment.`);
         }
         segments.push(appSegment);
         if (appSegment.interceptionMarker) {
             const parts = pathname.split(appSegment.interceptionMarker);
             if (parts.length !== 2) {
-                throw Object.defineProperty(new Error(`Invalid interception route: ${pathname}`), "__NEXT_ERROR_CODE", {
-                    value: "E924",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid interception route: ${pathname}`);
             }
             interceptingRoute = parseAppRouteImpl(parts[0], allowedTypes);
             interceptedRoute = parseAppRouteImpl(parts[1], allowedTypes);

package/app/node_modules/next/dist/shared/lib/router/utils/app-paths.js

@@ -58,7 +58,12 @@ function compareAppPaths(a, b) {
     if (!aHasSlot && bHasSlot) return 1;
     return a.localeCompare(b);
 }
-function selectAppPageEntry(pathname, appPaths, normalizePathname = (appPath)=>normalizeAppPath(appPath).replace(/%5F/g, '_')) {
+function normalizeAppPageEntryPathname(appPath) {
+    // Webpack app entries preserve escaped underscore segments as `%5F`, while
+    // normalized request pathnames expose the decoded `_` segment.
+    return normalizeAppPath(appPath).replace(/%5F/g, '_');
+}
+function selectAppPageEntry(pathname, appPaths, normalizePathname = normalizeAppPageEntryPathname) {
     let entry;
     for (const appPath of appPaths){
         if (normalizePathname(appPath) !== pathname) continue;

package/app/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js

@@ -50,8 +50,8 @@ const _resolveparamvalue = require("./resolve-param-value");
     if (fallbackRouteParams?.has(segmentKey)) {
         // We know that the fallback route params has the segment key because we
         // checked that above.
-        const [searchValue] = fallbackRouteParams.get(segmentKey);
-        value = searchValue;
+        const placeholder = fallbackRouteParams.get(segmentKey);
+        value = placeholder;
     } else if (Array.isArray(value)) {
         value = value.map((i)=>encodeURIComponent(i));
     } else if (typeof value === 'string') {
@@ -82,11 +82,7 @@ function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRo
             if (paramValue !== undefined) {
                 interpolated[paramName] = paramValue;
             } else if (paramType !== 'optional-catchall') {
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`), "__NEXT_ERROR_CODE", {
-                    value: "E932",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Could not resolve param value for segment: ${paramName}`);
             }
         }
         // Calculate next depth - increment if this is not a route group and not empty
@@ -122,11 +118,7 @@ function getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallb
                 ]
             };
         }
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`), "__NEXT_ERROR_CODE", {
-            value: "E864",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`);
     }
     const paramCacheKey = Array.isArray(value) ? value.join('/') : value;
     return {

package/app/node_modules/next/dist/shared/lib/router/utils/interception-routes.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     INTERCEPTION_ROUTE_MARKERS: null,
     extractInterceptionRouteInformation: null,
+    findMissingCanonicalInterceptionRoutes: null,
     isInterceptionRouteAppPath: null
 });
 function _export(target, all) {
@@ -20,6 +21,9 @@ _export(exports, {
     extractInterceptionRouteInformation: function() {
         return extractInterceptionRouteInformation;
     },
+    findMissingCanonicalInterceptionRoutes: function() {
+        return findMissingCanonicalInterceptionRoutes;
+    },
     isInterceptionRouteAppPath: function() {
         return isInterceptionRouteAppPath;
     }
@@ -31,6 +35,53 @@ const INTERCEPTION_ROUTE_MARKERS = [
     '(..)',
     '(...)'
 ];
+function parseRoutePattern(route) {
+    const segments = route.split('/').filter(Boolean);
+    const tail = segments.at(-1);
+    const isOptionalCatchAll = tail !== undefined && tail.startsWith('[[...') && tail.endsWith(']]');
+    const isCatchAll = tail !== undefined && tail.startsWith('[...') && tail.endsWith(']');
+    const unbounded = isOptionalCatchAll || isCatchAll;
+    const prefixSegments = unbounded ? segments.slice(0, -1) : segments;
+    return {
+        prefix: prefixSegments.map((segment)=>segment.startsWith('[') && segment.endsWith(']') ? null : segment),
+        minLength: prefixSegments.length + (isCatchAll && !isOptionalCatchAll ? 1 : 0),
+        unbounded
+    };
+}
+function acceptsLength(pattern, length) {
+    return pattern.unbounded ? length >= pattern.minLength : length === pattern.minLength;
+}
+function prefixCovers(canonical, intercepted) {
+    return canonical.prefix.every((canonicalSegment, index)=>{
+        if (canonicalSegment === null) return true;
+        const interceptedSegment = intercepted.prefix[index];
+        return interceptedSegment !== undefined && interceptedSegment !== null && canonicalSegment === interceptedSegment;
+    });
+}
+function patternCoversAtLength(canonical, intercepted, length) {
+    return acceptsLength(canonical, length) && acceptsLength(intercepted, length) && prefixCovers(canonical, intercepted);
+}
+/** Returns whether ordinary route patterns cover every URL in `route`. */ function isRoutePatternCovered(route, ordinaryRoutes) {
+    const intercepted = parseRoutePattern(route);
+    if (!intercepted.unbounded) {
+        return ordinaryRoutes.some((pattern)=>patternCoversAtLength(pattern, intercepted, intercepted.minLength));
+    }
+    let unboundedCoverageStart = Infinity;
+    for (const pattern of ordinaryRoutes){
+        if (pattern.unbounded && prefixCovers(pattern, intercepted)) {
+            unboundedCoverageStart = Math.min(unboundedCoverageStart, Math.max(intercepted.minLength, pattern.minLength));
+        }
+    }
+    if (unboundedCoverageStart === Infinity) return false;
+    // An optional or required catchall can have its shorter paths covered by
+    // fixed routes before another catchall takes over the remaining suffix.
+    for(let length = intercepted.minLength; length < unboundedCoverageStart; length++){
+        if (!ordinaryRoutes.some((pattern)=>patternCoversAtLength(pattern, intercepted, length))) {
+            return false;
+        }
+    }
+    return true;
+}
 function isInterceptionRouteAppPath(path) {
     // TODO-APP: add more serious validation
     return path.split('/').find((segment)=>INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m))) !== undefined;
@@ -48,11 +99,7 @@ function extractInterceptionRouteInformation(path) {
         }
     }
     if (!interceptingRoute || !marker || !interceptedRoute) {
-        throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`), "__NEXT_ERROR_CODE", {
-            value: "E269",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`);
     }
     interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute) // normalize the path, e.g. /(blog)/feed -> /feed
     ;
@@ -68,11 +115,7 @@ function extractInterceptionRouteInformation(path) {
         case '(..)':
             // (..) indicates that we should match at one level up, so we need to remove the last segment of the intercepting route
             if (interceptingRoute === '/') {
-                throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`), "__NEXT_ERROR_CODE", {
-                    value: "E207",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`);
             }
             interceptedRoute = interceptingRoute.split('/').slice(0, -1).concat(interceptedRoute).join('/');
             break;
@@ -84,25 +127,25 @@ function extractInterceptionRouteInformation(path) {
             // (..)(..) indicates that we should match at two levels up, so we need to remove the last two segments of the intercepting route
             const splitInterceptingRoute = interceptingRoute.split('/');
             if (splitInterceptingRoute.length <= 2) {
-                throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`), "__NEXT_ERROR_CODE", {
-                    value: "E486",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`);
             }
             interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join('/');
             break;
         default:
-            throw Object.defineProperty(new Error('Invariant: unexpected marker'), "__NEXT_ERROR_CODE", {
-                value: "E112",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Invariant: unexpected marker');
     }
     return {
         interceptingRoute,
         interceptedRoute
     };
 }
+function findMissingCanonicalInterceptionRoutes(appPaths) {
+    const canonicalRoutes = Object.keys(appPaths).filter((route)=>!isInterceptionRouteAppPath(route));
+    const canonicalRoutePatterns = canonicalRoutes.map(parseRoutePattern);
+    return Object.keys(appPaths).filter(isInterceptionRouteAppPath).map((interceptionRoute)=>({
+            interceptionRoute,
+            canonicalRoute: extractInterceptionRouteInformation(interceptionRoute).interceptedRoute
+        })).filter(({ canonicalRoute })=>!isRoutePatternCovered(canonicalRoute, canonicalRoutePatterns)).sort((a, b)=>a.interceptionRoute.localeCompare(b.interceptionRoute));
+}
 
 //# sourceMappingURL=interception-routes.js.map

package/app/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.js

@@ -17,11 +17,7 @@ function parseRelativeUrl(url, base, parseQuery = true) {
     // Not using `origin` to support other protocols
     new URL(`${resolvedBase.protocol}//${resolvedBase.host}${url}`) : new URL(url, resolvedBase);
     if (origin !== globalBase.origin) {
-        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
-            value: "E159",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`invariant: invalid relative URL, router received ${url}`);
     }
     return {
         auth: null,

package/app/node_modules/next/dist/shared/lib/router/utils/prepare-destination.js

@@ -267,11 +267,7 @@ function prepareDestination(args) {
         parsedDestination.search = destSearch ? compileNonPath(destSearch, args.params) : '';
     } catch (err) {
         if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
-            throw Object.defineProperty(new Error(`To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`), "__NEXT_ERROR_CODE", {
-                value: "E329",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`To use a multi-match in the destination you must add \`*\` at the end of the param name to signify it should repeat. https://nextjs.org/docs/messages/invalid-multi-match`);
         }
         throw err;
     }

package/app/node_modules/next/dist/shared/lib/router/utils/querystring.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     assign: null,
+    getRenderedSearch: null,
     searchParamsToUrlQuery: null,
     urlQueryToSearchParams: null
 });
@@ -17,6 +18,9 @@ _export(exports, {
     assign: function() {
         return assign;
     },
+    getRenderedSearch: function() {
+        return getRenderedSearch;
+    },
     searchParamsToUrlQuery: function() {
         return searchParamsToUrlQuery;
     },
@@ -24,6 +28,33 @@ _export(exports, {
         return urlQueryToSearchParams;
     }
 });
+function getRenderedSearch(query) {
+    // Inlined implementation of querystring.encode, which is not available in
+    // the Edge runtime.
+    const pairs = [];
+    for(const key in query){
+        const value = query[key];
+        if (value == null) continue;
+        if (Array.isArray(value)) {
+            for (const v of value){
+                pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(v))}`);
+            }
+        } else {
+            pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    // The result should match the format of a web URL's `search` property, since
+    // this is the format that's stored in the App Router state.
+    // TODO: We're a bit inconsistent about this. The x-nextjs-rewritten-query
+    // header omits the leading question mark. Should refactor to always do
+    // that instead.
+    if (pairs.length === 0) {
+        // If the search string is empty, return an empty string.
+        return '';
+    }
+    // Prepend '?' to the search params string.
+    return '?' + pairs.join('&');
+}
 function searchParamsToUrlQuery(searchParams) {
     const query = {};
     for (const [key, value] of searchParams.entries()){

package/app/node_modules/next/dist/shared/lib/router/utils/resolve-param-value.js

@@ -83,11 +83,7 @@ function resolveParamValue(paramName, paramType, depth, route, params) {
             } else {
                 // We shouldn't be able to match a catchall segment without any path
                 // segments if it's not an optional catchall
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`), "__NEXT_ERROR_CODE", {
-                    value: "E931",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Unexpected empty path segments match for a route "${route.pathname}" with param "${paramName}" of type "${paramType}"`);
             }
         case 'dynamic':
         case 'dynamic-intercepted-(..)(..)':

package/app/node_modules/next/dist/shared/lib/router/utils/route-matcher.js

@@ -18,11 +18,7 @@ function getRouteMatcher({ re, groups }) {
             try {
                 return decodeURIComponent(param);
             } catch  {
-                throw Object.defineProperty(new _utils.DecodeError('failed to decode param'), "__NEXT_ERROR_CODE", {
-                    value: "E528",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _utils.DecodeError('failed to decode param');
             }
         };
         const params = {};