@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/client/components/segment-cache/types.js

@@ -56,14 +56,23 @@ var FetchStrategy = /*#__PURE__*/ function(FetchStrategy) {
     // canNewFetchStrategyProvideMoreContent in cache.ts for what each tier can
     // contain relative to the others.
     //
+    // Full and LoadingBoundary belong to the non-Partial-Prefetching regime:
+    // they're only relevant in modes where the staging concepts (shell tiers,
+    // runtime prefetches) don't apply. They sit on this single ordered ladder
+    // as an accepted convenience, because cross-regime comparisons exist
+    // (e.g. canNewFetchStrategyProvideMoreContent).
+    //
     // These numeric values are client-internal and never cross the wire — the
     // `next-router-prefetch` request header values are mapped explicitly in
-    // fetchSegmentPrefetchesUsingDynamicRequest (cache.ts) — so the members can
+    // fetchSegmentPrefetchesUsingRuntimeRequest (cache.ts) — so the members can
     // be renumbered freely as long as the relative order is preserved.
     FetchStrategy[FetchStrategy["LoadingBoundary"] = 0] = "LoadingBoundary";
-    // The App Shell variant extracted from a static per-segment prefetch
+    // The shell-stage variant extracted from a static per-segment prefetch
     // response: every segment's param-dependent content is reduced to pending
-    // references that render as the param fallback. Less complete than
+    // references that render as the param fallback, keyed at the shell vary
+    // paths (only root params kept concrete). The Shell PHASE that issues
+    // these requests targets the conceptual App Shell; the strategy itself is
+    // just this mechanical truncation and keying. Less complete than
     // RuntimeShell — a static response can't include content that depends on
     // session data (cookies, headers) — and less complete than PPR at concrete
     // paths, which includes prerendered param-dependent content.

package/app/node_modules/next/dist/client/components/segment-cache/vary-path.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    ParamsChange: null,
     appendLayoutVaryPath: null,
-    clonePageVaryPathWithNewSearchParams: null,
-    finalizeLayoutVaryPath: null,
-    finalizeMetadataVaryPath: null,
-    finalizePageVaryPath: null,
+    cloneVaryPathWithNewSearchParams: null,
+    compareParams: null,
+    didReadChangedParam: null,
+    finalizeVaryPath: null,
     getFulfilledRouteVaryPath: null,
     getFulfilledSegmentVaryPath: null,
-    getPartialLayoutVaryPath: null,
-    getPartialPageVaryPath: null,
+    getPartialVaryPath: null,
     getRenderedSearchFromVaryPath: null,
     getRouteVaryPath: null,
     getSegmentVaryPathForRequest: null,
@@ -24,20 +24,23 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    ParamsChange: function() {
+        return ParamsChange;
+    },
     appendLayoutVaryPath: function() {
         return appendLayoutVaryPath;
     },
-    clonePageVaryPathWithNewSearchParams: function() {
-        return clonePageVaryPathWithNewSearchParams;
+    cloneVaryPathWithNewSearchParams: function() {
+        return cloneVaryPathWithNewSearchParams;
     },
-    finalizeLayoutVaryPath: function() {
-        return finalizeLayoutVaryPath;
+    compareParams: function() {
+        return compareParams;
     },
-    finalizeMetadataVaryPath: function() {
-        return finalizeMetadataVaryPath;
+    didReadChangedParam: function() {
+        return didReadChangedParam;
     },
-    finalizePageVaryPath: function() {
-        return finalizePageVaryPath;
+    finalizeVaryPath: function() {
+        return finalizeVaryPath;
     },
     getFulfilledRouteVaryPath: function() {
         return getFulfilledRouteVaryPath;
@@ -45,11 +48,8 @@ _export(exports, {
     getFulfilledSegmentVaryPath: function() {
         return getFulfilledSegmentVaryPath;
     },
-    getPartialLayoutVaryPath: function() {
-        return getPartialLayoutVaryPath;
-    },
-    getPartialPageVaryPath: function() {
-        return getPartialPageVaryPath;
+    getPartialVaryPath: function() {
+        return getPartialVaryPath;
     },
     getRenderedSearchFromVaryPath: function() {
         return getRenderedSearchFromVaryPath;
@@ -66,7 +66,7 @@ _export(exports, {
 });
 const _types = require("./types");
 const _cachemap = require("./cache-map");
-const _segmentvalueencoding = require("../../../shared/lib/segment-cache/segment-value-encoding");
+const _varyparamsdecoding = require("../../../shared/lib/segment-cache/vary-params-decoding");
 function getRouteVaryPath(pathname, search, nextUrl) {
     // requestKey -> searchParams -> nextUrl
     const varyPath = {
@@ -74,7 +74,7 @@ function getRouteVaryPath(pathname, search, nextUrl) {
         value: pathname,
         isRootParam: false,
         parent: {
-            id: '?',
+            id: _varyparamsdecoding.SEARCH_PARAMS_VARY_ID,
             value: search,
             isRootParam: false,
             parent: {
@@ -96,7 +96,7 @@ function getFulfilledRouteVaryPath(pathname, search, nextUrl, couldBeIntercepted
         value: pathname,
         isRootParam: false,
         parent: {
-            id: '?',
+            id: _varyparamsdecoding.SEARCH_PARAMS_VARY_ID,
             value: search,
             isRootParam: false,
             parent: {
@@ -118,79 +118,36 @@ function appendLayoutVaryPath(parentPath, cacheKey, paramName, isRootParam) {
     };
     return varyPathPart;
 }
-function finalizeLayoutVaryPath(requestKey, varyPath) {
-    const layoutVaryPath = {
-        id: null,
-        value: requestKey,
-        isRootParam: false,
-        parent: varyPath
-    };
-    return layoutVaryPath;
-}
-function getPartialLayoutVaryPath(finalizedVaryPath) {
-    // This is the inverse of finalizeLayoutVaryPath.
-    return finalizedVaryPath.parent;
-}
-function finalizePageVaryPath(requestKey, renderedSearch, varyPath) {
-    // Unlike layouts, a page segment's vary path also includes the search string.
-    // requestKey -> searchParams -> pathParams
-    const pageVaryPath = {
+function finalizeVaryPath(requestKey, // Non-null when the segment varies on search params: the search entry is
+// spliced in between the request key and the path params. Fallback keys an
+// entry that is reusable across all search strings.
+searchParams, partialVaryPath) {
+    // requestKey -> [searchParams] -> pathParams
+    let parent = partialVaryPath;
+    if (searchParams !== null) {
+        parent = {
+            id: _varyparamsdecoding.SEARCH_PARAMS_VARY_ID,
+            value: searchParams,
+            isRootParam: false,
+            parent: partialVaryPath
+        };
+    }
+    const varyPath = {
         id: null,
         value: requestKey,
         isRootParam: false,
-        parent: {
-            id: '?',
-            value: renderedSearch,
-            isRootParam: false,
-            parent: varyPath
-        }
+        parent
     };
-    return pageVaryPath;
-}
-function getPartialPageVaryPath(finalizedVaryPath) {
-    // This is the inverse of finalizePageVaryPath.
-    return finalizedVaryPath.parent.parent;
+    return varyPath;
 }
-function finalizeMetadataVaryPath(pageRequestKey, renderedSearch, varyPath) {
-    // The metadata "segment" is not a real segment because it doesn't exist in
-    // the normal structure of the route tree, but in terms of caching, it
-    // behaves like a page segment because it varies by all the same params as
-    // a page.
-    //
-    // To keep the protocol for querying the server simple, the request key for
-    // the metadata does not include any path information. It's unnecessary from
-    // the server's perspective, because unlike page segments, there's only one
-    // metadata response per URL, i.e. there's no need to distinguish multiple
-    // parallel pages.
-    //
-    // However, this means the metadata request key is insufficient for
-    // caching the the metadata in the client cache, because on the client we
-    // use the request key to distinguish the metadata entry from all other
-    // page's metadata entries.
-    //
-    // So instead we create a simulated request key based on the page segment.
-    // Conceptually this is equivalent to the request key the server would have
-    // assigned the metadata segment if it treated it as part of the actual
-    // route structure.
-    // If there are multiple parallel pages, we use whichever is the first one.
-    // This is fine because the only difference between request keys for
-    // different parallel pages are things like route groups and parallel
-    // route slots. As long as it's always the same one, it doesn't matter.
-    const pageVaryPath = {
-        id: null,
-        // Append the actual metadata request key to the page request key. Note
-        // that we're not using a separate vary path part; it's unnecessary because
-        // these are not conceptually separate inputs.
-        value: pageRequestKey + _segmentvalueencoding.HEAD_REQUEST_KEY,
-        isRootParam: false,
-        parent: {
-            id: '?',
-            value: renderedSearch,
-            isRootParam: false,
-            parent: varyPath
-        }
-    };
-    return pageVaryPath;
+function getPartialVaryPath(finalizedVaryPath) {
+    // This is the inverse of finalizeVaryPath: strip the request key, and the
+    // search params entry if there is one.
+    const parent = finalizedVaryPath.parent;
+    if (parent !== null && parent.id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+        return parent.parent;
+    }
+    return parent;
 }
 function getSegmentVaryPathForRequest(fetchStrategy, tree) {
     // This is used for storing pending requests in the cache. We want to choose
@@ -225,60 +182,117 @@ function getSegmentVaryPathForRequest(fetchStrategy, tree) {
         // params keep their concrete value).
         return tree.shellVaryPath;
     }
-    // Only page segments (and the special "metadata" segment, which is treated
-    // like a page segment for the purposes of caching) may contain search
-    // params. There's no reason to include them in the vary path otherwise.
-    if (tree.isPage) {
+    // The vary path includes a search params entry only when the segment varies
+    // on search params.
+    const searchParamsVaryPath = originalVaryPath.parent;
+    if (searchParamsVaryPath !== null && searchParamsVaryPath.id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
         // Only a runtime prefetch will include search params in the vary path.
         // Static prefetches never include search params, so they can be reused
         // across all possible search param values.
         const doesVaryOnSearchParams = fetchStrategy === _types.FetchStrategy.Full || fetchStrategy === _types.FetchStrategy.PPRRuntime;
         if (!doesVaryOnSearchParams) {
-            // The response from the the server will not vary on search params. Clone
-            // the end of the original vary path to replace the search params
-            // with Fallback.
+            // The response from the the server will not vary on search params.
+            // Rebuild the vary path with the search params replaced by Fallback.
             //
             // requestKey -> searchParams -> pathParams
             //               ^ This part gets replaced with Fallback
-            const searchParamsVaryPath = originalVaryPath.parent;
-            const pathParamsVaryPath = searchParamsVaryPath.parent;
-            const patchedVaryPath = {
-                id: null,
-                value: originalVaryPath.value,
-                isRootParam: false,
-                parent: {
-                    id: '?',
-                    value: _cachemap.Fallback,
-                    isRootParam: false,
-                    parent: pathParamsVaryPath
-                }
-            };
-            return patchedVaryPath;
+            return finalizeVaryPath(originalVaryPath.value, _cachemap.Fallback, getPartialVaryPath(originalVaryPath));
         }
     }
     // The request does vary on search params. We don't need to modify anything.
     return originalVaryPath;
 }
-function clonePageVaryPathWithNewSearchParams(originalVaryPath, newSearch) {
+function cloneVaryPathWithNewSearchParams(originalVaryPath, newSearch) {
     // requestKey -> searchParams -> pathParams
     //               ^ This part gets replaced with newSearch
     const searchParamsVaryPath = originalVaryPath.parent;
-    const clonedVaryPath = {
-        id: null,
-        value: originalVaryPath.value,
-        isRootParam: false,
-        parent: {
-            id: '?',
-            value: newSearch,
-            isRootParam: false,
-            parent: searchParamsVaryPath.parent
-        }
-    };
-    return clonedVaryPath;
+    if (searchParamsVaryPath === null || searchParamsVaryPath.id !== _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+        // No search params entry; nothing to replace.
+        return originalVaryPath;
+    }
+    return finalizeVaryPath(originalVaryPath.value, newSearch, getPartialVaryPath(originalVaryPath));
 }
 function getRenderedSearchFromVaryPath(varyPath) {
-    const searchParams = varyPath.parent.value;
-    return typeof searchParams === 'string' ? searchParams : null;
+    let node = varyPath;
+    while(node !== null){
+        if (node.id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+            const search = node.value;
+            if (typeof search === 'string') {
+                return search;
+            }
+            return null;
+        }
+        node = node.parent;
+    }
+    return null;
+}
+var ParamsChange = /*#__PURE__*/ function(ParamsChange) {
+    ParamsChange[ParamsChange["None"] = 0] = "None";
+    ParamsChange[ParamsChange["SearchParams"] = 1] = "SearchParams";
+    ParamsChange[ParamsChange["PathParam"] = 2] = "PathParam";
+    return ParamsChange;
+}({});
+function compareParams(currentVaryPath, nextVaryPath) {
+    // Both vary paths are for the same segment, so they list the same params in
+    // the same order. Walk them together. This includes params inherited from
+    // parent layouts, since those may have changed, too.
+    let current = currentVaryPath;
+    let next = nextVaryPath;
+    let change = 0;
+    while(current !== null && next !== null){
+        if (current.value !== next.value) {
+            const id = current.id;
+            if (id === null) {
+            // The request key. Callers check that the route structure matches
+            // first, so it's always the same.
+            } else if (id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+                change = 1;
+            } else {
+                return 2;
+            }
+        }
+        current = current.parent;
+        next = next.parent;
+    }
+    return change;
+}
+function didReadChangedParam(currentVaryPath, nextVaryPath, varyParams) {
+    // Returns true if the output rendered with `currentVaryPath` read a param
+    // whose value is different in `nextVaryPath`. `varyParams` is the set of
+    // params the output read, or null if we don't know.
+    //
+    // Same traversal as compareParams. Only read the set if a param changed.
+    let current = currentVaryPath;
+    let next = nextVaryPath;
+    let total = null;
+    while(current !== null && next !== null){
+        if (current.value !== next.value) {
+            const id = current.id;
+            if (id === null) {
+            // The request key. Callers check that the route structure matches
+            // first, so it's always the same.
+            } else {
+                if (total === null) {
+                    if (varyParams === null) {
+                        // We don't know. Assume it read the param.
+                        return true;
+                    }
+                    total = (0, _varyparamsdecoding.readVaryParams)(varyParams);
+                    if (total === null) {
+                        // The render hasn't finished, or it aborted. Assume it read the
+                        // param.
+                        return true;
+                    }
+                }
+                if (total.has(id)) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+        next = next.parent;
+    }
+    return false;
 }
 function getFulfilledSegmentVaryPath(original, varyParams) {
     // Re-keys a segment's vary path based on which params the segment actually

package/app/node_modules/next/dist/client/components/sequential-router-queue.js

@@ -0,0 +1,163 @@
+// The sequential-router-queue implementation of the navigator interface
+// (navigator.ts). Callers must never import this module directly; they import
+// './navigator', which resolves here unless `experimental.
+// concurrentRouterQueue` swaps in `./concurrent-router-queue` at the bundler
+// level (see create-compiler-aliases.ts and next_import_map.rs).
+//
+// The legacy reducer action objects are an implementation detail of the
+// sequential action queue; they are constructed here and never by callers.
+//
+// This module must remain free of side effects at module scope: in addition
+// to the browser bundle, a statically-resolved copy is compiled into the
+// pre-compiled app-page runtime bundles (via app-render.tsx), where the
+// bundler alias cannot reach. Only the browser copy's operations ever run.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    hmrRefresh: null,
+    navigate: null,
+    push: null,
+    refresh: null,
+    replace: null,
+    restore: null,
+    traverse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hmrRefresh: function() {
+        return hmrRefresh;
+    },
+    navigate: function() {
+        return navigate;
+    },
+    push: function() {
+        return push;
+    },
+    refresh: function() {
+        return refresh;
+    },
+    replace: function() {
+        return replace;
+    },
+    restore: function() {
+        return restore;
+    },
+    traverse: function() {
+        return traverse;
+    }
+});
+const _react = require("react");
+const _routerreducertypes = require("./router-reducer/router-reducer-types");
+const _useactionqueue = require("./use-action-queue");
+const _approuterinstance = require("./app-router-instance");
+const _links = require("./links");
+const _routertransition = require("./router-transition");
+const _addbasepath = require("../add-base-path");
+const _approuterutils = require("./app-router-utils");
+const _javascripturl = require("../lib/javascript-url");
+const _optimisticroutes = require("./segment-cache/optimistic-routes");
+function getRequiredAppRouterState() {
+    const state = (0, _approuterinstance.getCurrentAppRouterState)();
+    if (state === null) {
+        throw new Error('Internal Next.js error: Router action dispatched before initialization.');
+    }
+    return state;
+}
+function navigate(href, navigateType, scrollBehavior, linkInstanceRef, transitionTypes, prefetchIntent) {
+    if ((0, _javascripturl.isJavaScriptURLString)(href)) {
+        throw new Error('Next.js has blocked a javascript: URL as a security precaution.');
+    }
+    (0, _react.startTransition)(()=>{
+        // TODO: This stuff could just go into the reducer. Leaving as-is for now
+        // since we're about to rewrite all the router reducer stuff anyway.
+        if (transitionTypes) {
+            for (const type of transitionTypes){
+                (0, _react.addTransitionType)(type);
+            }
+        }
+        const url = new URL((0, _addbasepath.addBasePath)(href), location.href);
+        if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+            window.next.__pendingUrl = url;
+        }
+        (0, _links.setLinkForCurrentNavigation)(linkInstanceRef);
+        (0, _routertransition.startRouterTransition)(href, navigateType, getRequiredAppRouterState().tree, prefetchIntent);
+        (0, _useactionqueue.dispatchAppRouterAction)({
+            type: _routerreducertypes.ACTION_NAVIGATE,
+            url,
+            isExternalUrl: (0, _approuterutils.isExternalURL)(url),
+            locationSearch: location.search,
+            scrollBehavior,
+            navigateType
+        });
+    });
+}
+function push(href, options) {
+    navigate(href, 'push', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes, null);
+}
+function replace(href, options) {
+    navigate(href, 'replace', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes, null);
+}
+function traverse(href, historyState) {
+    (0, _react.startTransition)(()=>{
+        (0, _routertransition.startRouterTransition)(href, 'traverse', getRequiredAppRouterState().tree, null);
+        restore(new URL(href), historyState);
+    });
+}
+function restore(url, historyState) {
+    (0, _react.startTransition)(()=>{
+        (0, _useactionqueue.dispatchAppRouterAction)({
+            type: _routerreducertypes.ACTION_RESTORE,
+            url,
+            historyState
+        });
+    });
+}
+function refresh() {
+    (0, _react.startTransition)(()=>{
+        (0, _useactionqueue.dispatchAppRouterAction)({
+            type: _routerreducertypes.ACTION_REFRESH
+        });
+    });
+}
+// Tracks the newest HMR refresh generation so that a newer refresh can abort
+// the request of the one it supersedes. Development only.
+let activeHmrRefreshController = null;
+function hmrRefresh() {
+    if (process.env.NODE_ENV !== 'development') {
+        throw new Error('hmrRefresh can only be used in development mode. Please use refresh instead.');
+    } else {
+        // Reset the known routes table so that route predictions are cleared
+        // when routes change during development.
+        (0, _optimisticroutes.resetKnownRoutes)();
+        let signal;
+        if (process.env.__NEXT_SERVER_COMPONENTS_HMR_CANCELLATION) {
+            // Abort the superseded generation before scheduling the new one, so its
+            // request is torn down as early as possible. Halting (not rejecting)
+            // makes the abort safe regardless of order.
+            activeHmrRefreshController?.abort();
+            activeHmrRefreshController = new AbortController();
+            signal = activeHmrRefreshController.signal;
+        }
+        (0, _react.startTransition)(()=>{
+            (0, _useactionqueue.dispatchAppRouterAction)({
+                type: _routerreducertypes.ACTION_HMR_REFRESH,
+                signal
+            });
+        });
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=sequential-router-queue.js.map

package/app/node_modules/next/dist/client/components/unauthorized.js

@@ -25,17 +25,9 @@ const _httpaccessfallback = require("./http-access-fallback/http-access-fallback
  */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};401`;
 function unauthorized() {
     if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
-        throw Object.defineProperty(new Error(`\`unauthorized()\` is experimental and only allowed to be used when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
-            value: "E411",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`\`unauthorized()\` is experimental and only allowed to be used when \`experimental.authInterrupts\` is enabled.`);
     }
-    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E1002",
-        enumerable: false,
-        configurable: true
-    });
+    const error = new Error(DIGEST);
     error.digest = DIGEST;
     throw error;
 }

package/app/node_modules/next/dist/client/components/unstable-rethrow.js

@@ -9,13 +9,12 @@ Object.defineProperty(exports, "unstable_rethrow", {
     }
 });
 const _dynamicrenderingutils = require("../../server/dynamic-rendering-utils");
-const _ispostpone = require("../../server/lib/router-utils/is-postpone");
 const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
 const _isnextroutererror = require("./is-next-router-error");
 const _dynamicrendering = require("../../server/app-render/dynamic-rendering");
 const _hooksservercontext = require("./hooks-server-context");
 function unstable_rethrow(error) {
-    if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error) || (0, _hooksservercontext.isDynamicServerError)(error) || (0, _dynamicrendering.isDynamicPostpone)(error) || (0, _ispostpone.isPostpone)(error) || (0, _dynamicrenderingutils.isHangingPromiseRejectionError)(error) || (0, _dynamicrendering.isPrerenderInterruptedError)(error)) {
+    if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error) || (0, _hooksservercontext.isDynamicServerError)(error) || (0, _dynamicrenderingutils.isHangingPromiseRejectionError)(error) || (0, _dynamicrendering.isPrerenderInterruptedError)(error)) {
         throw error;
     }
     if (error instanceof Error && 'cause' in error) {

package/app/node_modules/next/dist/client/components/use-action-queue.js

@@ -50,11 +50,7 @@ function refreshOnInstantNavigationUnlock() {
 }
 function dispatchAppRouterAction(action) {
     if (dispatch === null) {
-        throw Object.defineProperty(new Error('Internal Next.js error: Router action dispatched before initialization.'), "__NEXT_ERROR_CODE", {
-            value: "E668",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Internal Next.js error: Router action dispatched before initialization.');
     }
     dispatch(action);
 }
@@ -63,11 +59,7 @@ function dispatchAppRouterAction(action) {
 let setGestureRouterState = null;
 function dispatchGestureState(state) {
     if (setGestureRouterState === null) {
-        throw Object.defineProperty(new Error('Internal Next.js error: Router action dispatched before initialization.'), "__NEXT_ERROR_CODE", {
-            value: "E668",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Internal Next.js error: Router action dispatched before initialization.');
     }
     setGestureRouterState(state);
 }