Initial boiler plate project

node_modules/next/dist/shared/lib/router/action-queue.d.ts

@@ -0,0 +1,22 @@
+import { type AppRouterState, type ReducerActions, type ReducerState } from '../../../client/components/router-reducer/router-reducer-types';
+import type { ReduxDevToolsInstance } from '../../../client/components/use-reducer-with-devtools';
+import React from 'react';
+export type DispatchStatePromise = React.Dispatch<ReducerState>;
+export type AppRouterActionQueue = {
+    state: AppRouterState | null;
+    devToolsInstance?: ReduxDevToolsInstance;
+    dispatch: (payload: ReducerActions, setState: DispatchStatePromise) => void;
+    action: (state: AppRouterState, action: ReducerActions) => ReducerState;
+    pending: ActionQueueNode | null;
+    needsRefresh?: boolean;
+    last: ActionQueueNode | null;
+};
+export type ActionQueueNode = {
+    payload: ReducerActions;
+    next: ActionQueueNode | null;
+    resolve: (value: ReducerState) => void;
+    reject: (err: Error) => void;
+    discarded?: boolean;
+};
+export declare const ActionQueueContext: React.Context<AppRouterActionQueue | null>;
+export declare function createMutableActionQueue(): AppRouterActionQueue;

node_modules/next/dist/shared/lib/router/action-queue.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ActionQueueContext: null,
+    createMutableActionQueue: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ActionQueueContext: function() {
+        return ActionQueueContext;
+    },
+    createMutableActionQueue: function() {
+        return createMutableActionQueue;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _routerreducertypes = require("../../../client/components/router-reducer/router-reducer-types");
+const _routerreducer = require("../../../client/components/router-reducer/router-reducer");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const ActionQueueContext = _react.default.createContext(null);
+function runRemainingActions(actionQueue, setState) {
+    if (actionQueue.pending !== null) {
+        actionQueue.pending = actionQueue.pending.next;
+        if (actionQueue.pending !== null) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            runAction({
+                actionQueue,
+                action: actionQueue.pending,
+                setState
+            });
+        } else {
+            // No more actions are pending, check if a refresh is needed
+            if (actionQueue.needsRefresh) {
+                actionQueue.needsRefresh = false;
+                actionQueue.dispatch({
+                    type: _routerreducertypes.ACTION_REFRESH,
+                    origin: window.location.origin
+                }, setState);
+            }
+        }
+    }
+}
+async function runAction(param) {
+    let { actionQueue, action, setState } = param;
+    const prevState = actionQueue.state;
+    if (!prevState) {
+        // This shouldn't happen as the state is initialized in the dispatcher if it's not set
+        throw new Error("Invariant: Router state not initialized");
+    }
+    actionQueue.pending = action;
+    const payload = action.payload;
+    const actionResult = actionQueue.action(prevState, payload);
+    function handleResult(nextState) {
+        // if we discarded this action, the state should also be discarded
+        if (action.discarded) {
+            return;
+        }
+        actionQueue.state = nextState;
+        if (actionQueue.devToolsInstance) {
+            actionQueue.devToolsInstance.send(payload, nextState);
+        }
+        runRemainingActions(actionQueue, setState);
+        action.resolve(nextState);
+    }
+    // if the action is a promise, set up a callback to resolve it
+    if ((0, _routerreducertypes.isThenable)(actionResult)) {
+        actionResult.then(handleResult, (err)=>{
+            runRemainingActions(actionQueue, setState);
+            action.reject(err);
+        });
+    } else {
+        handleResult(actionResult);
+    }
+}
+function dispatchAction(actionQueue, payload, setState) {
+    let resolvers = {
+        resolve: setState,
+        reject: ()=>{}
+    };
+    // most of the action types are async with the exception of restore
+    // it's important that restore is handled quickly since it's fired on the popstate event
+    // and we don't want to add any delay on a back/forward nav
+    // this only creates a promise for the async actions
+    if (payload.type !== _routerreducertypes.ACTION_RESTORE) {
+        // Create the promise and assign the resolvers to the object.
+        const deferredPromise = new Promise((resolve, reject)=>{
+            resolvers = {
+                resolve,
+                reject
+            };
+        });
+        (0, _react.startTransition)(()=>{
+            // we immediately notify React of the pending promise -- the resolver is attached to the action node
+            // and will be called when the associated action promise resolves
+            setState(deferredPromise);
+        });
+    }
+    const newAction = {
+        payload,
+        next: null,
+        resolve: resolvers.resolve,
+        reject: resolvers.reject
+    };
+    // Check if the queue is empty
+    if (actionQueue.pending === null) {
+        // The queue is empty, so add the action and start it immediately
+        // Mark this action as the last in the queue
+        actionQueue.last = newAction;
+        runAction({
+            actionQueue,
+            action: newAction,
+            setState
+        });
+    } else if (payload.type === _routerreducertypes.ACTION_NAVIGATE || payload.type === _routerreducertypes.ACTION_RESTORE) {
+        // Navigations (including back/forward) take priority over any pending actions.
+        // Mark the pending action as discarded (so the state is never applied) and start the navigation action immediately.
+        actionQueue.pending.discarded = true;
+        // Mark this action as the last in the queue
+        actionQueue.last = newAction;
+        // if the pending action was a server action, mark the queue as needing a refresh once events are processed
+        if (actionQueue.pending.payload.type === _routerreducertypes.ACTION_SERVER_ACTION) {
+            actionQueue.needsRefresh = true;
+        }
+        runAction({
+            actionQueue,
+            action: newAction,
+            setState
+        });
+    } else {
+        // The queue is not empty, so add the action to the end of the queue
+        // It will be started by runRemainingActions after the previous action finishes
+        if (actionQueue.last !== null) {
+            actionQueue.last.next = newAction;
+        }
+        actionQueue.last = newAction;
+    }
+}
+function createMutableActionQueue() {
+    const actionQueue = {
+        state: null,
+        dispatch: (payload, setState)=>dispatchAction(actionQueue, payload, setState),
+        action: async (state, action)=>{
+            if (state === null) {
+                throw new Error("Invariant: Router state not initialized");
+            }
+            const result = (0, _routerreducer.reducer)(state, action);
+            return result;
+        },
+        pending: null,
+        last: null
+    };
+    return actionQueue;
+}
+
+//# sourceMappingURL=action-queue.js.map

node_modules/next/dist/shared/lib/router/action-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/router/action-queue.ts"],"names":["ActionQueueContext","createMutableActionQueue","React","createContext","runRemainingActions","actionQueue","setState","pending","next","runAction","action","needsRefresh","dispatch","type","ACTION_REFRESH","origin","window","location","prevState","state","Error","payload","actionResult","handleResult","nextState","discarded","devToolsInstance","send","resolve","isThenable","then","err","reject","dispatchAction","resolvers","ACTION_RESTORE","deferredPromise","Promise","startTransition","newAction","last","ACTION_NAVIGATE","ACTION_SERVER_ACTION","result","reducer"],"mappings":";;;;;;;;;;;;;;;IAkCaA,kBAAkB;eAAlBA;;IA2JGC,wBAAwB;eAAxBA;;;;oCApLT;+BAEiB;iEACe;AAsBhC,MAAMD,qBACXE,cAAK,CAACC,aAAa,CAA8B;AAEnD,SAASC,oBACPC,WAAiC,EACjCC,QAA8B;IAE9B,IAAID,YAAYE,OAAO,KAAK,MAAM;QAChCF,YAAYE,OAAO,GAAGF,YAAYE,OAAO,CAACC,IAAI;QAC9C,IAAIH,YAAYE,OAAO,KAAK,MAAM;YAChC,mEAAmE;YACnEE,UAAU;gBACRJ;gBACAK,QAAQL,YAAYE,OAAO;gBAC3BD;YACF;QACF,OAAO;YACL,4DAA4D;YAC5D,IAAID,YAAYM,YAAY,EAAE;gBAC5BN,YAAYM,YAAY,GAAG;gBAC3BN,YAAYO,QAAQ,CAClB;oBACEC,MAAMC,kCAAc;oBACpBC,QAAQC,OAAOC,QAAQ,CAACF,MAAM;gBAChC,GACAT;YAEJ;QACF;IACF;AACF;AAEA,eAAeG,UAAU,KAQxB;IARwB,IAAA,EACvBJ,WAAW,EACXK,MAAM,EACNJ,QAAQ,EAKT,GARwB;IASvB,MAAMY,YAAYb,YAAYc,KAAK;IACnC,IAAI,CAACD,WAAW;QACd,sFAAsF;QACtF,MAAM,IAAIE,MAAM;IAClB;IAEAf,YAAYE,OAAO,GAAGG;IAEtB,MAAMW,UAAUX,OAAOW,OAAO;IAC9B,MAAMC,eAAejB,YAAYK,MAAM,CAACQ,WAAWG;IAEnD,SAASE,aAAaC,SAAyB;QAC7C,kEAAkE;QAClE,IAAId,OAAOe,SAAS,EAAE;YACpB;QACF;QAEApB,YAAYc,KAAK,GAAGK;QAEpB,IAAInB,YAAYqB,gBAAgB,EAAE;YAChCrB,YAAYqB,gBAAgB,CAACC,IAAI,CAACN,SAASG;QAC7C;QAEApB,oBAAoBC,aAAaC;QACjCI,OAAOkB,OAAO,CAACJ;IACjB;IAEA,8DAA8D;IAC9D,IAAIK,IAAAA,8BAAU,EAACP,eAAe;QAC5BA,aAAaQ,IAAI,CAACP,cAAc,CAACQ;YAC/B3B,oBAAoBC,aAAaC;YACjCI,OAAOsB,MAAM,CAACD;QAChB;IACF,OAAO;QACLR,aAAaD;IACf;AACF;AAEA,SAASW,eACP5B,WAAiC,EACjCgB,OAAuB,EACvBf,QAA8B;IAE9B,IAAI4B,YAGA;QAAEN,SAAStB;QAAU0B,QAAQ,KAAO;IAAE;IAE1C,mEAAmE;IACnE,wFAAwF;IACxF,2DAA2D;IAC3D,oDAAoD;IACpD,IAAIX,QAAQR,IAAI,KAAKsB,kCAAc,EAAE;QACnC,6DAA6D;QAC7D,MAAMC,kBAAkB,IAAIC,QAAwB,CAACT,SAASI;YAC5DE,YAAY;gBAAEN;gBAASI;YAAO;QAChC;QAEAM,IAAAA,sBAAe,EAAC;YACd,oGAAoG;YACpG,iEAAiE;YACjEhC,SAAS8B;QACX;IACF;IAEA,MAAMG,YAA6B;QACjClB;QACAb,MAAM;QACNoB,SAASM,UAAUN,OAAO;QAC1BI,QAAQE,UAAUF,MAAM;IAC1B;IAEA,8BAA8B;IAC9B,IAAI3B,YAAYE,OAAO,KAAK,MAAM;QAChC,iEAAiE;QACjE,4CAA4C;QAC5CF,YAAYmC,IAAI,GAAGD;QAEnB9B,UAAU;YACRJ;YACAK,QAAQ6B;YACRjC;QACF;IACF,OAAO,IACLe,QAAQR,IAAI,KAAK4B,mCAAe,IAChCpB,QAAQR,IAAI,KAAKsB,kCAAc,EAC/B;QACA,+EAA+E;QAC/E,oHAAoH;QACpH9B,YAAYE,OAAO,CAACkB,SAAS,GAAG;QAEhC,4CAA4C;QAC5CpB,YAAYmC,IAAI,GAAGD;QAEnB,2GAA2G;QAC3G,IAAIlC,YAAYE,OAAO,CAACc,OAAO,CAACR,IAAI,KAAK6B,wCAAoB,EAAE;YAC7DrC,YAAYM,YAAY,GAAG;QAC7B;QAEAF,UAAU;YACRJ;YACAK,QAAQ6B;YACRjC;QACF;IACF,OAAO;QACL,oEAAoE;QACpE,+EAA+E;QAC/E,IAAID,YAAYmC,IAAI,KAAK,MAAM;YAC7BnC,YAAYmC,IAAI,CAAChC,IAAI,GAAG+B;QAC1B;QACAlC,YAAYmC,IAAI,GAAGD;IACrB;AACF;AAEO,SAAStC;IACd,MAAMI,cAAoC;QACxCc,OAAO;QACPP,UAAU,CAACS,SAAyBf,WAClC2B,eAAe5B,aAAagB,SAASf;QACvCI,QAAQ,OAAOS,OAAuBT;YACpC,IAAIS,UAAU,MAAM;gBAClB,MAAM,IAAIC,MAAM;YAClB;YACA,MAAMuB,SAASC,IAAAA,sBAAO,EAACzB,OAAOT;YAC9B,OAAOiC;QACT;QACApC,SAAS;QACTiC,MAAM;IACR;IAEA,OAAOnC;AACT"}

node_modules/next/dist/shared/lib/router/adapters.d.ts

@@ -0,0 +1,18 @@
+import type { AppRouterInstance } from '../app-router-context.shared-runtime';
+import type { Params } from './utils/route-matcher';
+import type { NextRouter } from './router';
+import React from 'react';
+/** It adapts a Pages Router (`NextRouter`) to the App Router Instance. */
+export declare function adaptForAppRouterInstance(pagesRouter: NextRouter): AppRouterInstance;
+/**
+ * adaptForSearchParams transforms the ParsedURLQuery into URLSearchParams.
+ *
+ * @param router the router that contains the query.
+ * @returns the search params in the URLSearchParams format
+ */
+export declare function adaptForSearchParams(router: Pick<NextRouter, 'isReady' | 'query' | 'asPath'>): URLSearchParams;
+export declare function adaptForPathParams(router: Pick<NextRouter, 'isReady' | 'pathname' | 'query' | 'asPath'>): Params | null;
+export declare function PathnameContextProviderAdapter({ children, router, ...props }: React.PropsWithChildren<{
+    router: Pick<NextRouter, 'pathname' | 'asPath' | 'isReady' | 'isFallback'>;
+    isAutoExport: boolean;
+}>): import("react/jsx-runtime").JSX.Element;

node_modules/next/dist/shared/lib/router/adapters.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PathnameContextProviderAdapter: null,
+    adaptForAppRouterInstance: null,
+    adaptForPathParams: null,
+    adaptForSearchParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PathnameContextProviderAdapter: function() {
+        return PathnameContextProviderAdapter;
+    },
+    adaptForAppRouterInstance: function() {
+        return adaptForAppRouterInstance;
+    },
+    adaptForPathParams: function() {
+        return adaptForPathParams;
+    },
+    adaptForSearchParams: function() {
+        return adaptForSearchParams;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _hooksclientcontextsharedruntime = require("../hooks-client-context.shared-runtime");
+const _utils = require("./utils");
+const _aspathtosearchparams = require("./utils/as-path-to-search-params");
+const _routeregex = require("./utils/route-regex");
+function adaptForAppRouterInstance(pagesRouter) {
+    return {
+        back () {
+            pagesRouter.back();
+        },
+        forward () {
+            pagesRouter.forward();
+        },
+        refresh () {
+            pagesRouter.reload();
+        },
+        fastRefresh () {},
+        push (href, param) {
+            let { scroll } = param === void 0 ? {} : param;
+            void pagesRouter.push(href, undefined, {
+                scroll
+            });
+        },
+        replace (href, param) {
+            let { scroll } = param === void 0 ? {} : param;
+            void pagesRouter.replace(href, undefined, {
+                scroll
+            });
+        },
+        prefetch (href) {
+            void pagesRouter.prefetch(href);
+        }
+    };
+}
+function adaptForSearchParams(router) {
+    if (!router.isReady || !router.query) {
+        return new URLSearchParams();
+    }
+    return (0, _aspathtosearchparams.asPathToSearchParams)(router.asPath);
+}
+function adaptForPathParams(router) {
+    if (!router.isReady || !router.query) {
+        return null;
+    }
+    const pathParams = {};
+    const routeRegex = (0, _routeregex.getRouteRegex)(router.pathname);
+    const keys = Object.keys(routeRegex.groups);
+    for (const key of keys){
+        pathParams[key] = router.query[key];
+    }
+    return pathParams;
+}
+function PathnameContextProviderAdapter(param) {
+    let { children, router, ...props } = param;
+    const ref = (0, _react.useRef)(props.isAutoExport);
+    const value = (0, _react.useMemo)(()=>{
+        // isAutoExport is only ever `true` on the first render from the server,
+        // so reset it to `false` after we read it for the first time as `true`. If
+        // we don't use the value, then we don't need it.
+        const isAutoExport = ref.current;
+        if (isAutoExport) {
+            ref.current = false;
+        }
+        // When the route is a dynamic route, we need to do more processing to
+        // determine if we need to stop showing the pathname.
+        if ((0, _utils.isDynamicRoute)(router.pathname)) {
+            // When the router is rendering the fallback page, it can't possibly know
+            // the path, so return `null` here. Read more about fallback pages over
+            // at:
+            // https://nextjs.org/docs/api-reference/data-fetching/get-static-paths#fallback-pages
+            if (router.isFallback) {
+                return null;
+            }
+            // When `isAutoExport` is true, meaning this is a page page has been
+            // automatically statically optimized, and the router is not ready, then
+            // we can't know the pathname yet. Read more about automatic static
+            // optimization at:
+            // https://nextjs.org/docs/advanced-features/automatic-static-optimization
+            if (isAutoExport && !router.isReady) {
+                return null;
+            }
+        }
+        // The `router.asPath` contains the pathname seen by the browser (including
+        // any query strings), so it should have that stripped. Read more about the
+        // `asPath` option over at:
+        // https://nextjs.org/docs/api-reference/next/router#router-object
+        let url;
+        try {
+            url = new URL(router.asPath, "http://f");
+        } catch (_) {
+            // fallback to / for invalid asPath values e.g. //
+            return "/";
+        }
+        return url.pathname;
+    }, [
+        router.asPath,
+        router.isFallback,
+        router.isReady,
+        router.pathname
+    ]);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.PathnameContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+
+//# sourceMappingURL=adapters.js.map

node_modules/next/dist/shared/lib/router/adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/lib/router/adapters.tsx"],"names":["PathnameContextProviderAdapter","adaptForAppRouterInstance","adaptForPathParams","adaptForSearchParams","pagesRouter","back","forward","refresh","reload","fastRefresh","push","href","scroll","undefined","replace","prefetch","router","isReady","query","URLSearchParams","asPathToSearchParams","asPath","pathParams","routeRegex","getRouteRegex","pathname","keys","Object","groups","key","children","props","ref","useRef","isAutoExport","value","useMemo","current","isDynamicRoute","isFallback","url","URL","_","PathnameContext","Provider"],"mappings":";;;;;;;;;;;;;;;;;IAoEgBA,8BAA8B;eAA9BA;;IAzDAC,yBAAyB;eAAzBA;;IA0CAC,kBAAkB;eAAlBA;;IAVAC,oBAAoB;eAApBA;;;;;iEAvCuB;iDACP;uBACD;sCACM;4BACP;AAGvB,SAASF,0BACdG,WAAuB;IAEvB,OAAO;QACLC;YACED,YAAYC,IAAI;QAClB;QACAC;YACEF,YAAYE,OAAO;QACrB;QACAC;YACEH,YAAYI,MAAM;QACpB;QACAC,gBAAe;QACfC,MAAKC,IAAI,EAAE;YAAA,IAAA,EAAEC,MAAM,EAAE,GAAV,mBAAa,CAAC,IAAd;YACT,KAAKR,YAAYM,IAAI,CAACC,MAAME,WAAW;gBAAED;YAAO;QAClD;QACAE,SAAQH,IAAI,EAAE;YAAA,IAAA,EAAEC,MAAM,EAAE,GAAV,mBAAa,CAAC,IAAd;YACZ,KAAKR,YAAYU,OAAO,CAACH,MAAME,WAAW;gBAAED;YAAO;QACrD;QACAG,UAASJ,IAAI;YACX,KAAKP,YAAYW,QAAQ,CAACJ;QAC5B;IACF;AACF;AAQO,SAASR,qBACda,MAAwD;IAExD,IAAI,CAACA,OAAOC,OAAO,IAAI,CAACD,OAAOE,KAAK,EAAE;QACpC,OAAO,IAAIC;IACb;IAEA,OAAOC,IAAAA,0CAAoB,EAACJ,OAAOK,MAAM;AAC3C;AAEO,SAASnB,mBACdc,MAAqE;IAErE,IAAI,CAACA,OAAOC,OAAO,IAAI,CAACD,OAAOE,KAAK,EAAE;QACpC,OAAO;IACT;IACA,MAAMI,aAAqB,CAAC;IAC5B,MAAMC,aAAaC,IAAAA,yBAAa,EAACR,OAAOS,QAAQ;IAChD,MAAMC,OAAOC,OAAOD,IAAI,CAACH,WAAWK,MAAM;IAC1C,KAAK,MAAMC,OAAOH,KAAM;QACtBJ,UAAU,CAACO,IAAI,GAAGb,OAAOE,KAAK,CAACW,IAAI;IACrC;IACA,OAAOP;AACT;AAEO,SAAStB,+BAA+B,KAO7C;IAP6C,IAAA,EAC7C8B,QAAQ,EACRd,MAAM,EACN,GAAGe,OAIH,GAP6C;IAQ7C,MAAMC,MAAMC,IAAAA,aAAM,EAACF,MAAMG,YAAY;IACrC,MAAMC,QAAQC,IAAAA,cAAO,EAAC;QACpB,wEAAwE;QACxE,2EAA2E;QAC3E,iDAAiD;QACjD,MAAMF,eAAeF,IAAIK,OAAO;QAChC,IAAIH,cAAc;YAChBF,IAAIK,OAAO,GAAG;QAChB;QAEA,sEAAsE;QACtE,qDAAqD;QACrD,IAAIC,IAAAA,qBAAc,EAACtB,OAAOS,QAAQ,GAAG;YACnC,yEAAyE;YACzE,uEAAuE;YACvE,MAAM;YACN,sFAAsF;YACtF,IAAIT,OAAOuB,UAAU,EAAE;gBACrB,OAAO;YACT;YAEA,oEAAoE;YACpE,wEAAwE;YACxE,mEAAmE;YACnE,mBAAmB;YACnB,0EAA0E;YAC1E,IAAIL,gBAAgB,CAAClB,OAAOC,OAAO,EAAE;gBACnC,OAAO;YACT;QACF;QAEA,2EAA2E;QAC3E,2EAA2E;QAC3E,2BAA2B;QAC3B,kEAAkE;QAClE,IAAIuB;QACJ,IAAI;YACFA,MAAM,IAAIC,IAAIzB,OAAOK,MAAM,EAAE;QAC/B,EAAE,OAAOqB,GAAG;YACV,kDAAkD;YAClD,OAAO;QACT;QAEA,OAAOF,IAAIf,QAAQ;IACrB,GAAG;QAACT,OAAOK,MAAM;QAAEL,OAAOuB,UAAU;QAAEvB,OAAOC,OAAO;QAAED,OAAOS,QAAQ;KAAC;IAEtE,qBACE,qBAACkB,gDAAe,CAACC,QAAQ;QAACT,OAAOA;kBAC9BL;;AAGP"}

node_modules/next/dist/shared/lib/router/adapters.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/shared/lib/router/router.d.ts

@@ -0,0 +1,234 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ComponentType } from 'react';
+import type { DomainLocale } from '../../../server/config';
+import type { MittEmitter } from '../mitt';
+import type { ParsedUrlQuery } from 'querystring';
+import type { RouterEvent } from '../../../client/router';
+import type { StyleSheetTuple } from '../../../client/page-loader';
+import type { UrlObject } from 'url';
+import type PageLoader from '../../../client/page-loader';
+import type { NextPageContext, NEXT_DATA } from '../utils';
+declare global {
+    interface Window {
+        __NEXT_DATA__: NEXT_DATA;
+    }
+}
+interface RouteProperties {
+    shallow: boolean;
+}
+interface TransitionOptions {
+    shallow?: boolean;
+    locale?: string | false;
+    scroll?: boolean;
+    unstable_skipClientCache?: boolean;
+}
+interface NextHistoryState {
+    url: string;
+    as: string;
+    options: TransitionOptions;
+}
+export type HistoryState = null | {
+    __NA: true;
+    __N?: false;
+} | {
+    __N: false;
+    __NA?: false;
+} | ({
+    __NA?: false;
+    __N: true;
+    key: string;
+} & NextHistoryState);
+interface MiddlewareEffectParams<T extends FetchDataOutput> {
+    fetchData?: () => Promise<T>;
+    locale?: string;
+    asPath: string;
+    router: Router;
+}
+export declare function matchesMiddleware<T extends FetchDataOutput>(options: MiddlewareEffectParams<T>): Promise<boolean>;
+export type Url = UrlObject | string;
+export type BaseRouter = {
+    route: string;
+    pathname: string;
+    query: ParsedUrlQuery;
+    asPath: string;
+    basePath: string;
+    locale?: string | undefined;
+    locales?: string[] | undefined;
+    defaultLocale?: string | undefined;
+    domainLocales?: DomainLocale[] | undefined;
+    isLocaleDomain: boolean;
+};
+export type NextRouter = BaseRouter & Pick<Router, 'push' | 'replace' | 'reload' | 'back' | 'forward' | 'prefetch' | 'beforePopState' | 'events' | 'isFallback' | 'isReady' | 'isPreview'>;
+export type PrefetchOptions = {
+    priority?: boolean;
+    locale?: string | false;
+    unstable_skipClientCache?: boolean;
+};
+export type PrivateRouteInfo = (Omit<CompletePrivateRouteInfo, 'styleSheets'> & {
+    initial: true;
+}) | CompletePrivateRouteInfo;
+export type CompletePrivateRouteInfo = {
+    Component: ComponentType;
+    styleSheets: StyleSheetTuple[];
+    __N_SSG?: boolean;
+    __N_SSP?: boolean;
+    props?: Record<string, any>;
+    err?: Error;
+    error?: any;
+    route?: string;
+    resolvedAs?: string;
+    query?: ParsedUrlQuery;
+};
+export type AppProps = Pick<CompletePrivateRouteInfo, 'Component' | 'err'> & {
+    router: Router;
+} & Record<string, any>;
+export type AppComponent = ComponentType<AppProps>;
+type Subscription = (data: PrivateRouteInfo, App: AppComponent, resetScroll: {
+    x: number;
+    y: number;
+} | null) => Promise<void>;
+type BeforePopStateCallback = (state: NextHistoryState) => boolean;
+type ComponentLoadCancel = (() => void) | null;
+type HistoryMethod = 'replaceState' | 'pushState';
+interface FetchDataOutput {
+    dataHref: string;
+    json: Record<string, any> | null;
+    response: Response;
+    text: string;
+    cacheKey: string;
+}
+interface NextDataCache {
+    [asPath: string]: Promise<FetchDataOutput>;
+}
+export declare function createKey(): string;
+export default class Router implements BaseRouter {
+    basePath: string;
+    /**
+     * Map of all components loaded in `Router`
+     */
+    components: {
+        [pathname: string]: PrivateRouteInfo;
+    };
+    sdc: NextDataCache;
+    sbc: NextDataCache;
+    sub: Subscription;
+    clc: ComponentLoadCancel;
+    pageLoader: PageLoader;
+    _bps: BeforePopStateCallback | undefined;
+    events: MittEmitter<RouterEvent>;
+    _wrapApp: (App: AppComponent) => any;
+    isSsr: boolean;
+    _inFlightRoute?: string | undefined;
+    _shallow?: boolean | undefined;
+    locales?: string[] | undefined;
+    defaultLocale?: string | undefined;
+    domainLocales?: DomainLocale[] | undefined;
+    isReady: boolean;
+    isLocaleDomain: boolean;
+    isFirstPopStateEvent: boolean;
+    _initialMatchesMiddlewarePromise: Promise<boolean>;
+    _bfl_s?: import('../../lib/bloom-filter').BloomFilter;
+    _bfl_d?: import('../../lib/bloom-filter').BloomFilter;
+    private state;
+    private _key;
+    static events: MittEmitter<RouterEvent>;
+    constructor(pathname: string, query: ParsedUrlQuery, as: string, { initialProps, pageLoader, App, wrapApp, Component, err, subscription, isFallback, locale, locales, defaultLocale, domainLocales, isPreview, }: {
+        subscription: Subscription;
+        initialProps: any;
+        pageLoader: any;
+        Component: ComponentType;
+        App: AppComponent;
+        wrapApp: (WrapAppComponent: AppComponent) => any;
+        err?: Error;
+        isFallback: boolean;
+        locale?: string;
+        locales?: string[];
+        defaultLocale?: string;
+        domainLocales?: DomainLocale[];
+        isPreview?: boolean;
+    });
+    onPopState: (e: PopStateEvent) => void;
+    reload(): void;
+    /**
+     * Go back in history
+     */
+    back(): void;
+    /**
+     * Go forward in history
+     */
+    forward(): void;
+    /**
+     * Performs a `pushState` with arguments
+     * @param url of the route
+     * @param as masks `url` for the browser
+     * @param options object you can define `shallow` and other options
+     */
+    push(url: Url, as?: Url, options?: TransitionOptions): Promise<boolean>;
+    /**
+     * Performs a `replaceState` with arguments
+     * @param url of the route
+     * @param as masks `url` for the browser
+     * @param options object you can define `shallow` and other options
+     */
+    replace(url: Url, as?: Url, options?: TransitionOptions): Promise<boolean>;
+    _bfl(as: string, resolvedAs?: string, locale?: string | false, skipNavigate?: boolean): Promise<unknown>;
+    private change;
+    changeState(method: HistoryMethod, url: string, as: string, options?: TransitionOptions): void;
+    handleRouteInfoError(err: Error & {
+        code?: any;
+        cancelled?: boolean;
+    }, pathname: string, query: ParsedUrlQuery, as: string, routeProps: RouteProperties, loadErrorFail?: boolean): Promise<CompletePrivateRouteInfo>;
+    getRouteInfo({ route: requestedRoute, pathname, query, as, resolvedAs, routeProps, locale, hasMiddleware, isPreview, unstable_skipClientCache, isQueryUpdating, isMiddlewareRewrite, isNotFound, }: {
+        route: string;
+        pathname: string;
+        query: ParsedUrlQuery;
+        as: string;
+        resolvedAs: string;
+        hasMiddleware?: boolean;
+        routeProps: RouteProperties;
+        locale: string | undefined;
+        isPreview: boolean;
+        unstable_skipClientCache?: boolean;
+        isQueryUpdating?: boolean;
+        isMiddlewareRewrite?: boolean;
+        isNotFound?: boolean;
+    }): Promise<{
+        type: "redirect-external";
+        destination: string;
+    } | {
+        type: "redirect-internal";
+        newAs: string;
+        newUrl: string;
+    } | PrivateRouteInfo>;
+    private set;
+    /**
+     * Callback to execute before replacing router state
+     * @param cb callback to be executed
+     */
+    beforePopState(cb: BeforePopStateCallback): void;
+    onlyAHashChange(as: string): boolean;
+    scrollToHash(as: string): void;
+    urlIsNew(asPath: string): boolean;
+    /**
+     * Prefetch page code, you may wait for the data during page rendering.
+     * This feature only works in production!
+     * @param url the href of prefetched page
+     * @param asPath the as path of the prefetched page
+     */
+    prefetch(url: string, asPath?: string, options?: PrefetchOptions): Promise<void>;
+    fetchComponent(route: string): Promise<import("../../../client/page-loader").GoodPageCache>;
+    _getData<T>(fn: () => Promise<T>): Promise<T>;
+    _getFlightData(dataHref: string): Promise<{
+        data: string;
+    }>;
+    getInitialProps(Component: ComponentType, ctx: NextPageContext): Promise<Record<string, any>>;
+    get route(): string;
+    get pathname(): string;
+    get query(): ParsedUrlQuery;
+    get asPath(): string;
+    get locale(): string | undefined;
+    get isFallback(): boolean;
+    get isPreview(): boolean;
+}
+export {};

node_modules/next/dist/shared/lib/router/utils/add-locale.d.ts

@@ -0,0 +1,6 @@
+/**
+ * For a given path and a locale, if the locale is given, it will prefix the
+ * locale. The path shouldn't be an API path. If a default locale is given the
+ * prefix will be omitted if the locale is already the default locale.
+ */
+export declare function addLocale(path: string, locale?: string | false, defaultLocale?: string, ignorePrefix?: boolean): string;

node_modules/next/dist/shared/lib/router/utils/add-locale.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "addLocale", {
+    enumerable: true,
+    get: function() {
+        return addLocale;
+    }
+});
+const _addpathprefix = require("./add-path-prefix");
+const _pathhasprefix = require("./path-has-prefix");
+function addLocale(path, locale, defaultLocale, ignorePrefix) {
+    // If no locale was given or the locale is the default locale, we don't need
+    // to prefix the path.
+    if (!locale || locale === defaultLocale) return path;
+    const lower = path.toLowerCase();
+    // If the path is an API path or the path already has the locale prefix, we
+    // don't need to prefix the path.
+    if (!ignorePrefix) {
+        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/api")) return path;
+        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase())) return path;
+    }
+    // Add the locale prefix to the path.
+    return (0, _addpathprefix.addPathPrefix)(path, "/" + locale);
+}
+
+//# sourceMappingURL=add-locale.js.map

node_modules/next/dist/shared/lib/router/utils/add-locale.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/add-locale.ts"],"names":["addLocale","path","locale","defaultLocale","ignorePrefix","lower","toLowerCase","pathHasPrefix","addPathPrefix"],"mappings":";;;;+BAQgBA;;;eAAAA;;;+BARc;+BACA;AAOvB,SAASA,UACdC,IAAY,EACZC,MAAuB,EACvBC,aAAsB,EACtBC,YAAsB;IAEtB,4EAA4E;IAC5E,sBAAsB;IACtB,IAAI,CAACF,UAAUA,WAAWC,eAAe,OAAOF;IAEhD,MAAMI,QAAQJ,KAAKK,WAAW;IAE9B,2EAA2E;IAC3E,iCAAiC;IACjC,IAAI,CAACF,cAAc;QACjB,IAAIG,IAAAA,4BAAa,EAACF,OAAO,SAAS,OAAOJ;QACzC,IAAIM,IAAAA,4BAAa,EAACF,OAAO,AAAC,MAAGH,OAAOI,WAAW,KAAO,OAAOL;IAC/D;IAEA,qCAAqC;IACrC,OAAOO,IAAAA,4BAAa,EAACP,MAAM,AAAC,MAAGC;AACjC"}

node_modules/next/dist/shared/lib/router/utils/add-path-prefix.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Adds the provided prefix to the given path. It first ensures that the path
+ * is indeed starting with a slash.
+ */
+export declare function addPathPrefix(path: string, prefix?: string): string;

node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "addPathPrefix", {
+    enumerable: true,
+    get: function() {
+        return addPathPrefix;
+    }
+});
+const _parsepath = require("./parse-path");
+function addPathPrefix(path, prefix) {
+    if (!path.startsWith("/") || !prefix) {
+        return path;
+    }
+    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+    return "" + prefix + pathname + query + hash;
+}
+
+//# sourceMappingURL=add-path-prefix.js.map

node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/add-path-prefix.ts"],"names":["addPathPrefix","path","prefix","startsWith","pathname","query","hash","parsePath"],"mappings":";;;;+BAMgBA;;;eAAAA;;;2BANU;AAMnB,SAASA,cAAcC,IAAY,EAAEC,MAAe;IACzD,IAAI,CAACD,KAAKE,UAAU,CAAC,QAAQ,CAACD,QAAQ;QACpC,OAAOD;IACT;IAEA,MAAM,EAAEG,QAAQ,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGC,IAAAA,oBAAS,EAACN;IAC5C,OAAO,AAAC,KAAEC,SAASE,WAAWC,QAAQC;AACxC"}

node_modules/next/dist/shared/lib/router/utils/add-path-suffix.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Similarly to `addPathPrefix`, this function adds a suffix at the end on the
+ * provided path. It also works only for paths ensuring the argument starts
+ * with a slash.
+ */
+export declare function addPathSuffix(path: string, suffix?: string): string;

node_modules/next/dist/shared/lib/router/utils/add-path-suffix.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "addPathSuffix", {
+    enumerable: true,
+    get: function() {
+        return addPathSuffix;
+    }
+});
+const _parsepath = require("./parse-path");
+function addPathSuffix(path, suffix) {
+    if (!path.startsWith("/") || !suffix) {
+        return path;
+    }
+    const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+    return "" + pathname + suffix + query + hash;
+}
+
+//# sourceMappingURL=add-path-suffix.js.map

node_modules/next/dist/shared/lib/router/utils/add-path-suffix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/add-path-suffix.ts"],"names":["addPathSuffix","path","suffix","startsWith","pathname","query","hash","parsePath"],"mappings":";;;;+BAOgBA;;;eAAAA;;;2BAPU;AAOnB,SAASA,cAAcC,IAAY,EAAEC,MAAe;IACzD,IAAI,CAACD,KAAKE,UAAU,CAAC,QAAQ,CAACD,QAAQ;QACpC,OAAOD;IACT;IAEA,MAAM,EAAEG,QAAQ,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGC,IAAAA,oBAAS,EAACN;IAC5C,OAAO,AAAC,KAAEG,WAAWF,SAASG,QAAQC;AACxC"}

node_modules/next/dist/shared/lib/router/utils/app-paths.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Normalizes an app route so it represents the actual request path. Essentially
+ * performing the following transformations:
+ *
+ * - `/(dashboard)/user/[id]/page` to `/user/[id]`
+ * - `/(dashboard)/account/page` to `/account`
+ * - `/user/[id]/page` to `/user/[id]`
+ * - `/account/page` to `/account`
+ * - `/page` to `/`
+ * - `/(dashboard)/user/[id]/route` to `/user/[id]`
+ * - `/(dashboard)/account/route` to `/account`
+ * - `/user/[id]/route` to `/user/[id]`
+ * - `/account/route` to `/account`
+ * - `/route` to `/`
+ * - `/` to `/`
+ *
+ * @param route the app route to normalize
+ * @returns the normalized pathname
+ */
+export declare function normalizeAppPath(route: string): string;
+/**
+ * Strips the `.rsc` extension if it's in the pathname.
+ * Since this function is used on full urls it checks `?` for searchParams handling.
+ */
+export declare function normalizeRscURL(url: string): string;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    normalizeAppPath: null,
+    normalizeRscURL: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    normalizeAppPath: function() {
+        return normalizeAppPath;
+    },
+    normalizeRscURL: function() {
+        return normalizeRscURL;
+    }
+});
+const _ensureleadingslash = require("../../page-path/ensure-leading-slash");
+const _segment = require("../../segment");
+function normalizeAppPath(route) {
+    return (0, _ensureleadingslash.ensureLeadingSlash)(route.split("/").reduce((pathname, segment, index, segments)=>{
+        // Empty segments are ignored.
+        if (!segment) {
+            return pathname;
+        }
+        // Groups are ignored.
+        if ((0, _segment.isGroupSegment)(segment)) {
+            return pathname;
+        }
+        // Parallel segments are ignored.
+        if (segment[0] === "@") {
+            return pathname;
+        }
+        // The last segment (if it's a leaf) should be ignored.
+        if ((segment === "page" || segment === "route") && index === segments.length - 1) {
+            return pathname;
+        }
+        return pathname + "/" + segment;
+    }, ""));
+}
+function normalizeRscURL(url) {
+    return url.replace(/\.rsc($|\?)/, // $1 ensures `?` is preserved
+    "$1");
+}
+
+//# sourceMappingURL=app-paths.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/app-paths.ts"],"names":["normalizeAppPath","normalizeRscURL","route","ensureLeadingSlash","split","reduce","pathname","segment","index","segments","isGroupSegment","length","url","replace"],"mappings":";;;;;;;;;;;;;;;IAsBgBA,gBAAgB;eAAhBA;;IAmCAC,eAAe;eAAfA;;;oCAzDmB;yBACJ;AAqBxB,SAASD,iBAAiBE,KAAa;IAC5C,OAAOC,IAAAA,sCAAkB,EACvBD,MAAME,KAAK,CAAC,KAAKC,MAAM,CAAC,CAACC,UAAUC,SAASC,OAAOC;QACjD,8BAA8B;QAC9B,IAAI,CAACF,SAAS;YACZ,OAAOD;QACT;QAEA,sBAAsB;QACtB,IAAII,IAAAA,uBAAc,EAACH,UAAU;YAC3B,OAAOD;QACT;QAEA,iCAAiC;QACjC,IAAIC,OAAO,CAAC,EAAE,KAAK,KAAK;YACtB,OAAOD;QACT;QAEA,uDAAuD;QACvD,IACE,AAACC,CAAAA,YAAY,UAAUA,YAAY,OAAM,KACzCC,UAAUC,SAASE,MAAM,GAAG,GAC5B;YACA,OAAOL;QACT;QAEA,OAAO,AAAGA,WAAS,MAAGC;IACxB,GAAG;AAEP;AAMO,SAASN,gBAAgBW,GAAW;IACzC,OAAOA,IAAIC,OAAO,CAChB,eACA,8BAA8B;IAC9B;AAEJ"}

node_modules/next/dist/shared/lib/router/utils/app-paths.test.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/next/dist/shared/lib/router/utils/as-path-to-search-params.d.ts

@@ -0,0 +1 @@
+export declare function asPathToSearchParams(asPath: string): URLSearchParams;

node_modules/next/dist/shared/lib/router/utils/as-path-to-search-params.js

@@ -0,0 +1,17 @@
+// Convert router.asPath to a URLSearchParams object
+// example: /dynamic/[slug]?foo=bar -> { foo: 'bar' }
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "asPathToSearchParams", {
+    enumerable: true,
+    get: function() {
+        return asPathToSearchParams;
+    }
+});
+function asPathToSearchParams(asPath) {
+    return new URL(asPath, "http://n").searchParams;
+}
+
+//# sourceMappingURL=as-path-to-search-params.js.map

node_modules/next/dist/shared/lib/router/utils/as-path-to-search-params.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/as-path-to-search-params.ts"],"names":["asPathToSearchParams","asPath","URL","searchParams"],"mappings":"AAAA,oDAAoD;AACpD,qDAAqD;;;;;+BACrCA;;;eAAAA;;;AAAT,SAASA,qBAAqBC,MAAc;IACjD,OAAO,IAAIC,IAAID,QAAQ,YAAYE,YAAY;AACjD"}

node_modules/next/dist/shared/lib/router/utils/compare-states.d.ts

@@ -0,0 +1,2 @@
+import type { default as Router } from '../router';
+export declare function compareRouterStates(a: Router['state'], b: Router['state']): boolean;

node_modules/next/dist/shared/lib/router/utils/compare-states.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "compareRouterStates", {
+    enumerable: true,
+    get: function() {
+        return compareRouterStates;
+    }
+});
+function compareRouterStates(a, b) {
+    const stateKeys = Object.keys(a);
+    if (stateKeys.length !== Object.keys(b).length) return false;
+    for(let i = stateKeys.length; i--;){
+        const key = stateKeys[i];
+        if (key === "query") {
+            const queryKeys = Object.keys(a.query);
+            if (queryKeys.length !== Object.keys(b.query).length) {
+                return false;
+            }
+            for(let j = queryKeys.length; j--;){
+                const queryKey = queryKeys[j];
+                if (!b.query.hasOwnProperty(queryKey) || a.query[queryKey] !== b.query[queryKey]) {
+                    return false;
+                }
+            }
+        } else if (!b.hasOwnProperty(key) || a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+//# sourceMappingURL=compare-states.js.map

node_modules/next/dist/shared/lib/router/utils/compare-states.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/compare-states.ts"],"names":["compareRouterStates","a","b","stateKeys","Object","keys","length","i","key","queryKeys","query","j","queryKey","hasOwnProperty"],"mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,oBAAoBC,CAAkB,EAAEC,CAAkB;IACxE,MAAMC,YAAYC,OAAOC,IAAI,CAACJ;IAC9B,IAAIE,UAAUG,MAAM,KAAKF,OAAOC,IAAI,CAACH,GAAGI,MAAM,EAAE,OAAO;IAEvD,IAAK,IAAIC,IAAIJ,UAAUG,MAAM,EAAEC,KAAO;QACpC,MAAMC,MAAML,SAAS,CAACI,EAAE;QACxB,IAAIC,QAAQ,SAAS;YACnB,MAAMC,YAAYL,OAAOC,IAAI,CAACJ,EAAES,KAAK;YACrC,IAAID,UAAUH,MAAM,KAAKF,OAAOC,IAAI,CAACH,EAAEQ,KAAK,EAAEJ,MAAM,EAAE;gBACpD,OAAO;YACT;YACA,IAAK,IAAIK,IAAIF,UAAUH,MAAM,EAAEK,KAAO;gBACpC,MAAMC,WAAWH,SAAS,CAACE,EAAE;gBAC7B,IACE,CAACT,EAAEQ,KAAK,CAACG,cAAc,CAACD,aACxBX,EAAES,KAAK,CAACE,SAAS,KAAKV,EAAEQ,KAAK,CAACE,SAAS,EACvC;oBACA,OAAO;gBACT;YACF;QACF,OAAO,IACL,CAACV,EAAEW,cAAc,CAACL,QAClBP,CAAC,CAACO,IAA6B,KAAKN,CAAC,CAACM,IAA6B,EACnE;YACA,OAAO;QACT;IACF;IAEA,OAAO;AACT"}

node_modules/next/dist/shared/lib/router/utils/escape-path-delimiters.d.ts

@@ -0,0 +1 @@
+export default function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string;

node_modules/next/dist/shared/lib/router/utils/escape-path-delimiters.js

@@ -0,0 +1,16 @@
+// escape delimiters used by path-to-regexp
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return escapePathDelimiters;
+    }
+});
+function escapePathDelimiters(segment, escapeEncoded) {
+    return segment.replace(new RegExp("([/#?]" + (escapeEncoded ? "|%(2f|23|3f)" : "") + ")", "gi"), (char)=>encodeURIComponent(char));
+}
+
+//# sourceMappingURL=escape-path-delimiters.js.map

node_modules/next/dist/shared/lib/router/utils/escape-path-delimiters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/escape-path-delimiters.ts"],"names":["escapePathDelimiters","segment","escapeEncoded","replace","RegExp","char","encodeURIComponent"],"mappings":"AAAA,2CAA2C;;;;;+BAC3C;;;eAAwBA;;;AAAT,SAASA,qBACtBC,OAAe,EACfC,aAAuB;IAEvB,OAAOD,QAAQE,OAAO,CACpB,IAAIC,OAAO,AAAC,WAAQF,CAAAA,gBAAgB,iBAAiB,EAAC,IAAE,KAAI,OAC5D,CAACG,OAAiBC,mBAAmBD;AAEzC"}

node_modules/next/dist/shared/lib/router/utils/format-next-pathname-info.d.ts

@@ -0,0 +1,7 @@
+import type { NextPathnameInfo } from './get-next-pathname-info';
+interface ExtendedInfo extends NextPathnameInfo {
+    defaultLocale?: string;
+    ignorePrefix?: boolean;
+}
+export declare function formatNextPathnameInfo(info: ExtendedInfo): string;
+export {};

node_modules/next/dist/shared/lib/router/utils/format-next-pathname-info.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatNextPathnameInfo", {
+    enumerable: true,
+    get: function() {
+        return formatNextPathnameInfo;
+    }
+});
+const _removetrailingslash = require("./remove-trailing-slash");
+const _addpathprefix = require("./add-path-prefix");
+const _addpathsuffix = require("./add-path-suffix");
+const _addlocale = require("./add-locale");
+function formatNextPathnameInfo(info) {
+    let pathname = (0, _addlocale.addLocale)(info.pathname, info.locale, info.buildId ? undefined : info.defaultLocale, info.ignorePrefix);
+    if (info.buildId || !info.trailingSlash) {
+        pathname = (0, _removetrailingslash.removeTrailingSlash)(pathname);
+    }
+    if (info.buildId) {
+        pathname = (0, _addpathsuffix.addPathSuffix)((0, _addpathprefix.addPathPrefix)(pathname, "/_next/data/" + info.buildId), info.pathname === "/" ? "index.json" : ".json");
+    }
+    pathname = (0, _addpathprefix.addPathPrefix)(pathname, info.basePath);
+    return !info.buildId && info.trailingSlash ? !pathname.endsWith("/") ? (0, _addpathsuffix.addPathSuffix)(pathname, "/") : pathname : (0, _removetrailingslash.removeTrailingSlash)(pathname);
+}
+
+//# sourceMappingURL=format-next-pathname-info.js.map

node_modules/next/dist/shared/lib/router/utils/format-next-pathname-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/format-next-pathname-info.ts"],"names":["formatNextPathnameInfo","info","pathname","addLocale","locale","buildId","undefined","defaultLocale","ignorePrefix","trailingSlash","removeTrailingSlash","addPathSuffix","addPathPrefix","basePath","endsWith"],"mappings":";;;;+BAWgBA;;;eAAAA;;;qCAVoB;+BACN;+BACA;2BACJ;AAOnB,SAASA,uBAAuBC,IAAkB;IACvD,IAAIC,WAAWC,IAAAA,oBAAS,EACtBF,KAAKC,QAAQ,EACbD,KAAKG,MAAM,EACXH,KAAKI,OAAO,GAAGC,YAAYL,KAAKM,aAAa,EAC7CN,KAAKO,YAAY;IAGnB,IAAIP,KAAKI,OAAO,IAAI,CAACJ,KAAKQ,aAAa,EAAE;QACvCP,WAAWQ,IAAAA,wCAAmB,EAACR;IACjC;IAEA,IAAID,KAAKI,OAAO,EAAE;QAChBH,WAAWS,IAAAA,4BAAa,EACtBC,IAAAA,4BAAa,EAACV,UAAU,AAAC,iBAAcD,KAAKI,OAAO,GACnDJ,KAAKC,QAAQ,KAAK,MAAM,eAAe;IAE3C;IAEAA,WAAWU,IAAAA,4BAAa,EAACV,UAAUD,KAAKY,QAAQ;IAChD,OAAO,CAACZ,KAAKI,OAAO,IAAIJ,KAAKQ,aAAa,GACtC,CAACP,SAASY,QAAQ,CAAC,OACjBH,IAAAA,4BAAa,EAACT,UAAU,OACxBA,WACFQ,IAAAA,wCAAmB,EAACR;AAC1B"}

node_modules/next/dist/shared/lib/router/utils/format-url.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { UrlObject } from 'url';
+export declare function formatUrl(urlObj: UrlObject): string;
+export declare const urlObjectKeys: string[];
+export declare function formatWithValidation(url: UrlObject): string;

node_modules/next/dist/shared/lib/router/utils/format-url.js

@@ -0,0 +1,111 @@
+// Format function modified from nodejs
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatUrl: null,
+    formatWithValidation: null,
+    urlObjectKeys: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatUrl: function() {
+        return formatUrl;
+    },
+    formatWithValidation: function() {
+        return formatWithValidation;
+    },
+    urlObjectKeys: function() {
+        return urlObjectKeys;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _querystring = /*#__PURE__*/ _interop_require_wildcard._(require("./querystring"));
+const slashedProtocols = /https?|ftp|gopher|file/;
+function formatUrl(urlObj) {
+    let { auth, hostname } = urlObj;
+    let protocol = urlObj.protocol || "";
+    let pathname = urlObj.pathname || "";
+    let hash = urlObj.hash || "";
+    let query = urlObj.query || "";
+    let host = false;
+    auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ":") + "@" : "";
+    if (urlObj.host) {
+        host = auth + urlObj.host;
+    } else if (hostname) {
+        host = auth + (~hostname.indexOf(":") ? "[" + hostname + "]" : hostname);
+        if (urlObj.port) {
+            host += ":" + urlObj.port;
+        }
+    }
+    if (query && typeof query === "object") {
+        query = String(_querystring.urlQueryToSearchParams(query));
+    }
+    let search = urlObj.search || query && "?" + query || "";
+    if (protocol && !protocol.endsWith(":")) protocol += ":";
+    if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+        host = "//" + (host || "");
+        if (pathname && pathname[0] !== "/") pathname = "/" + pathname;
+    } else if (!host) {
+        host = "";
+    }
+    if (hash && hash[0] !== "#") hash = "#" + hash;
+    if (search && search[0] !== "?") search = "?" + search;
+    pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+    search = search.replace("#", "%23");
+    return "" + protocol + host + pathname + search + hash;
+}
+const urlObjectKeys = [
+    "auth",
+    "hash",
+    "host",
+    "hostname",
+    "href",
+    "path",
+    "pathname",
+    "port",
+    "protocol",
+    "query",
+    "search",
+    "slashes"
+];
+function formatWithValidation(url) {
+    if (process.env.NODE_ENV === "development") {
+        if (url !== null && typeof url === "object") {
+            Object.keys(url).forEach((key)=>{
+                if (!urlObjectKeys.includes(key)) {
+                    console.warn("Unknown key passed via urlObject into url.format: " + key);
+                }
+            });
+        }
+    }
+    return formatUrl(url);
+}
+
+//# sourceMappingURL=format-url.js.map

node_modules/next/dist/shared/lib/router/utils/format-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/format-url.ts"],"names":["formatUrl","formatWithValidation","urlObjectKeys","slashedProtocols","urlObj","auth","hostname","protocol","pathname","hash","query","host","encodeURIComponent","replace","indexOf","port","String","querystring","urlQueryToSearchParams","search","endsWith","slashes","test","url","process","env","NODE_ENV","Object","keys","forEach","key","includes","console","warn"],"mappings":"AAAA,uCAAuC;AACvC,sDAAsD;AACtD,EAAE;AACF,0EAA0E;AAC1E,gEAAgE;AAChE,sEAAsE;AACtE,sEAAsE;AACtE,4EAA4E;AAC5E,qEAAqE;AACrE,wBAAwB;AACxB,EAAE;AACF,0EAA0E;AAC1E,yDAAyD;AACzD,EAAE;AACF,0EAA0E;AAC1E,6DAA6D;AAC7D,4EAA4E;AAC5E,2EAA2E;AAC3E,wEAAwE;AACxE,4EAA4E;AAC5E,yCAAyC;;;;;;;;;;;;;;;;;IAQzBA,SAAS;eAATA;;IA6DAC,oBAAoB;eAApBA;;IAfHC,aAAa;eAAbA;;;;uEAlDgB;AAE7B,MAAMC,mBAAmB;AAElB,SAASH,UAAUI,MAAiB;IACzC,IAAI,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGF;IACzB,IAAIG,WAAWH,OAAOG,QAAQ,IAAI;IAClC,IAAIC,WAAWJ,OAAOI,QAAQ,IAAI;IAClC,IAAIC,OAAOL,OAAOK,IAAI,IAAI;IAC1B,IAAIC,QAAQN,OAAOM,KAAK,IAAI;IAC5B,IAAIC,OAAuB;IAE3BN,OAAOA,OAAOO,mBAAmBP,MAAMQ,OAAO,CAAC,QAAQ,OAAO,MAAM;IAEpE,IAAIT,OAAOO,IAAI,EAAE;QACfA,OAAON,OAAOD,OAAOO,IAAI;IAC3B,OAAO,IAAIL,UAAU;QACnBK,OAAON,OAAQ,CAAA,CAACC,SAASQ,OAAO,CAAC,OAAO,AAAC,MAAGR,WAAS,MAAKA,QAAO;QACjE,IAAIF,OAAOW,IAAI,EAAE;YACfJ,QAAQ,MAAMP,OAAOW,IAAI;QAC3B;IACF;IAEA,IAAIL,SAAS,OAAOA,UAAU,UAAU;QACtCA,QAAQM,OAAOC,aAAYC,sBAAsB,CAACR;IACpD;IAEA,IAAIS,SAASf,OAAOe,MAAM,IAAKT,SAAS,AAAC,MAAGA,SAAY;IAExD,IAAIH,YAAY,CAACA,SAASa,QAAQ,CAAC,MAAMb,YAAY;IAErD,IACEH,OAAOiB,OAAO,IACb,AAAC,CAAA,CAACd,YAAYJ,iBAAiBmB,IAAI,CAACf,SAAQ,KAAMI,SAAS,OAC5D;QACAA,OAAO,OAAQA,CAAAA,QAAQ,EAAC;QACxB,IAAIH,YAAYA,QAAQ,CAAC,EAAE,KAAK,KAAKA,WAAW,MAAMA;IACxD,OAAO,IAAI,CAACG,MAAM;QAChBA,OAAO;IACT;IAEA,IAAIF,QAAQA,IAAI,CAAC,EAAE,KAAK,KAAKA,OAAO,MAAMA;IAC1C,IAAIU,UAAUA,MAAM,CAAC,EAAE,KAAK,KAAKA,SAAS,MAAMA;IAEhDX,WAAWA,SAASK,OAAO,CAAC,SAASD;IACrCO,SAASA,OAAON,OAAO,CAAC,KAAK;IAE7B,OAAO,AAAC,KAAEN,WAAWI,OAAOH,WAAWW,SAASV;AAClD;AAEO,MAAMP,gBAAgB;IAC3B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAEM,SAASD,qBAAqBsB,GAAc;IACjD,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,IAAIH,QAAQ,QAAQ,OAAOA,QAAQ,UAAU;YAC3CI,OAAOC,IAAI,CAACL,KAAKM,OAAO,CAAC,CAACC;gBACxB,IAAI,CAAC5B,cAAc6B,QAAQ,CAACD,MAAM;oBAChCE,QAAQC,IAAI,CACV,AAAC,uDAAoDH;gBAEzD;YACF;QACF;IACF;IAEA,OAAO9B,UAAUuB;AACnB"}

node_modules/next/dist/shared/lib/router/utils/get-asset-path-from-route.d.ts

@@ -0,0 +1 @@
+export default function getAssetPathFromRoute(route: string, ext?: string): string;

node_modules/next/dist/shared/lib/router/utils/get-asset-path-from-route.js

@@ -0,0 +1,19 @@
+// Translates a logical route into its pages asset path (relative from a common prefix)
+// "asset path" being its javascript file, data file, prerendered html,...
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return getAssetPathFromRoute;
+    }
+});
+function getAssetPathFromRoute(route, ext) {
+    if (ext === void 0) ext = "";
+    const path = route === "/" ? "/index" : /^\/index(\/|$)/.test(route) ? "/index" + route : route;
+    return path + ext;
+}
+
+//# sourceMappingURL=get-asset-path-from-route.js.map

node_modules/next/dist/shared/lib/router/utils/get-asset-path-from-route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/get-asset-path-from-route.ts"],"names":["getAssetPathFromRoute","route","ext","path","test"],"mappings":"AAAA,uFAAuF;AACvF,0EAA0E;;;;;+BAC1E;;;eAAwBA;;;AAAT,SAASA,sBACtBC,KAAa,EACbC,GAAgB;IAAhBA,IAAAA,gBAAAA,MAAc;IAEd,MAAMC,OACJF,UAAU,MACN,WACA,iBAAiBG,IAAI,CAACH,SACtB,AAAC,WAAQA,QACTA;IACN,OAAOE,OAAOD;AAChB"}

node_modules/next/dist/shared/lib/router/utils/get-next-pathname-info.d.ts

@@ -0,0 +1,49 @@
+import type { I18NProvider } from '../../../../server/future/helpers/i18n-provider';
+export interface NextPathnameInfo {
+    /**
+     * The base path in case the pathname included it.
+     */
+    basePath?: string;
+    /**
+     * The buildId for when the parsed URL is a data URL. Parsing it can be
+     * disabled with the `parseData` option.
+     */
+    buildId?: string;
+    /**
+     * If there was a locale in the pathname, this will hold its value.
+     */
+    locale?: string;
+    /**
+     * The processed pathname without a base path, locale, or data URL elements
+     * when parsing it is enabled.
+     */
+    pathname: string;
+    /**
+     * A boolean telling if the pathname had a trailingSlash. This can be only
+     * true if trailingSlash is enabled.
+     */
+    trailingSlash?: boolean;
+}
+interface Options {
+    /**
+     * When passed to true, this function will also parse Nextjs data URLs.
+     */
+    parseData?: boolean;
+    /**
+     * A partial of the Next.js configuration to parse the URL.
+     */
+    nextConfig?: {
+        basePath?: string;
+        i18n?: {
+            locales?: string[];
+        } | null;
+        trailingSlash?: boolean;
+    };
+    /**
+     * If provided, this normalizer will be used to detect the locale instead of
+     * the default locale detection.
+     */
+    i18nProvider?: I18NProvider;
+}
+export declare function getNextPathnameInfo(pathname: string, options: Options): NextPathnameInfo;
+export {};

node_modules/next/dist/shared/lib/router/utils/get-next-pathname-info.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNextPathnameInfo", {
+    enumerable: true,
+    get: function() {
+        return getNextPathnameInfo;
+    }
+});
+const _normalizelocalepath = require("../../i18n/normalize-locale-path");
+const _removepathprefix = require("./remove-path-prefix");
+const _pathhasprefix = require("./path-has-prefix");
+function getNextPathnameInfo(pathname, options) {
+    var _options_nextConfig;
+    const { basePath, i18n, trailingSlash } = (_options_nextConfig = options.nextConfig) != null ? _options_nextConfig : {};
+    const info = {
+        pathname,
+        trailingSlash: pathname !== "/" ? pathname.endsWith("/") : trailingSlash
+    };
+    if (basePath && (0, _pathhasprefix.pathHasPrefix)(info.pathname, basePath)) {
+        info.pathname = (0, _removepathprefix.removePathPrefix)(info.pathname, basePath);
+        info.basePath = basePath;
+    }
+    let pathnameNoDataPrefix = info.pathname;
+    if (info.pathname.startsWith("/_next/data/") && info.pathname.endsWith(".json")) {
+        const paths = info.pathname.replace(/^\/_next\/data\//, "").replace(/\.json$/, "").split("/");
+        const buildId = paths[0];
+        info.buildId = buildId;
+        pathnameNoDataPrefix = paths[1] !== "index" ? "/" + paths.slice(1).join("/") : "/";
+        // update pathname with normalized if enabled although
+        // we use normalized to populate locale info still
+        if (options.parseData === true) {
+            info.pathname = pathnameNoDataPrefix;
+        }
+    }
+    // If provided, use the locale route normalizer to detect the locale instead
+    // of the function below.
+    if (i18n) {
+        let result = options.i18nProvider ? options.i18nProvider.analyze(info.pathname) : (0, _normalizelocalepath.normalizeLocalePath)(info.pathname, i18n.locales);
+        info.locale = result.detectedLocale;
+        var _result_pathname;
+        info.pathname = (_result_pathname = result.pathname) != null ? _result_pathname : info.pathname;
+        if (!result.detectedLocale && info.buildId) {
+            result = options.i18nProvider ? options.i18nProvider.analyze(pathnameNoDataPrefix) : (0, _normalizelocalepath.normalizeLocalePath)(pathnameNoDataPrefix, i18n.locales);
+            if (result.detectedLocale) {
+                info.locale = result.detectedLocale;
+            }
+        }
+    }
+    return info;
+}
+
+//# sourceMappingURL=get-next-pathname-info.js.map

node_modules/next/dist/shared/lib/router/utils/get-next-pathname-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/get-next-pathname-info.ts"],"names":["getNextPathnameInfo","pathname","options","basePath","i18n","trailingSlash","nextConfig","info","endsWith","pathHasPrefix","removePathPrefix","pathnameNoDataPrefix","startsWith","paths","replace","split","buildId","slice","join","parseData","result","i18nProvider","analyze","normalizeLocalePath","locales","locale","detectedLocale"],"mappings":";;;;+BAoDgBA;;;eAAAA;;;qCApDoB;kCACH;+BACH;AAkDvB,SAASA,oBACdC,QAAgB,EAChBC,OAAgB;QAE0BA;IAA1C,MAAM,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,aAAa,EAAE,GAAGH,CAAAA,sBAAAA,QAAQI,UAAU,YAAlBJ,sBAAsB,CAAC;IACjE,MAAMK,OAAyB;QAC7BN;QACAI,eAAeJ,aAAa,MAAMA,SAASO,QAAQ,CAAC,OAAOH;IAC7D;IAEA,IAAIF,YAAYM,IAAAA,4BAAa,EAACF,KAAKN,QAAQ,EAAEE,WAAW;QACtDI,KAAKN,QAAQ,GAAGS,IAAAA,kCAAgB,EAACH,KAAKN,QAAQ,EAAEE;QAChDI,KAAKJ,QAAQ,GAAGA;IAClB;IACA,IAAIQ,uBAAuBJ,KAAKN,QAAQ;IAExC,IACEM,KAAKN,QAAQ,CAACW,UAAU,CAAC,mBACzBL,KAAKN,QAAQ,CAACO,QAAQ,CAAC,UACvB;QACA,MAAMK,QAAQN,KAAKN,QAAQ,CACxBa,OAAO,CAAC,oBAAoB,IAC5BA,OAAO,CAAC,WAAW,IACnBC,KAAK,CAAC;QAET,MAAMC,UAAUH,KAAK,CAAC,EAAE;QACxBN,KAAKS,OAAO,GAAGA;QACfL,uBACEE,KAAK,CAAC,EAAE,KAAK,UAAU,AAAC,MAAGA,MAAMI,KAAK,CAAC,GAAGC,IAAI,CAAC,OAAS;QAE1D,sDAAsD;QACtD,kDAAkD;QAClD,IAAIhB,QAAQiB,SAAS,KAAK,MAAM;YAC9BZ,KAAKN,QAAQ,GAAGU;QAClB;IACF;IAEA,4EAA4E;IAC5E,yBAAyB;IACzB,IAAIP,MAAM;QACR,IAAIgB,SAASlB,QAAQmB,YAAY,GAC7BnB,QAAQmB,YAAY,CAACC,OAAO,CAACf,KAAKN,QAAQ,IAC1CsB,IAAAA,wCAAmB,EAAChB,KAAKN,QAAQ,EAAEG,KAAKoB,OAAO;QAEnDjB,KAAKkB,MAAM,GAAGL,OAAOM,cAAc;YACnBN;QAAhBb,KAAKN,QAAQ,GAAGmB,CAAAA,mBAAAA,OAAOnB,QAAQ,YAAfmB,mBAAmBb,KAAKN,QAAQ;QAEhD,IAAI,CAACmB,OAAOM,cAAc,IAAInB,KAAKS,OAAO,EAAE;YAC1CI,SAASlB,QAAQmB,YAAY,GACzBnB,QAAQmB,YAAY,CAACC,OAAO,CAACX,wBAC7BY,IAAAA,wCAAmB,EAACZ,sBAAsBP,KAAKoB,OAAO;YAE1D,IAAIJ,OAAOM,cAAc,EAAE;gBACzBnB,KAAKkB,MAAM,GAAGL,OAAOM,cAAc;YACrC;QACF;IACF;IACA,OAAOnB;AACT"}

node_modules/next/dist/shared/lib/router/utils/get-route-from-asset-path.d.ts

@@ -0,0 +1 @@
+export default function getRouteFromAssetPath(assetPath: string, ext?: string): string;

node_modules/next/dist/shared/lib/router/utils/get-route-from-asset-path.js

@@ -0,0 +1,26 @@
+// Translate a pages asset path (relative from a common prefix) back into its logical route
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, // "asset path" being its javascript file, data file, prerendered html,...
+"default", {
+    enumerable: true,
+    get: function() {
+        return getRouteFromAssetPath;
+    }
+});
+const _isdynamic = require("./is-dynamic");
+function getRouteFromAssetPath(assetPath, ext) {
+    if (ext === void 0) ext = "";
+    assetPath = assetPath.replace(/\\/g, "/");
+    assetPath = ext && assetPath.endsWith(ext) ? assetPath.slice(0, -ext.length) : assetPath;
+    if (assetPath.startsWith("/index/") && !(0, _isdynamic.isDynamicRoute)(assetPath)) {
+        assetPath = assetPath.slice(6);
+    } else if (assetPath === "/index") {
+        assetPath = "/";
+    }
+    return assetPath;
+}
+
+//# sourceMappingURL=get-route-from-asset-path.js.map

node_modules/next/dist/shared/lib/router/utils/get-route-from-asset-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/get-route-from-asset-path.ts"],"names":["getRouteFromAssetPath","assetPath","ext","replace","endsWith","slice","length","startsWith","isDynamicRoute"],"mappings":"AAAA,2FAA2F;;;;;+BAI3F,0EAA0E;AAC1E;;;eAAwBA;;;2BAHO;AAGhB,SAASA,sBACtBC,SAAiB,EACjBC,GAAgB;IAAhBA,IAAAA,gBAAAA,MAAc;IAEdD,YAAYA,UAAUE,OAAO,CAAC,OAAO;IACrCF,YACEC,OAAOD,UAAUG,QAAQ,CAACF,OAAOD,UAAUI,KAAK,CAAC,GAAG,CAACH,IAAII,MAAM,IAAIL;IACrE,IAAIA,UAAUM,UAAU,CAAC,cAAc,CAACC,IAAAA,yBAAc,EAACP,YAAY;QACjEA,YAAYA,UAAUI,KAAK,CAAC;IAC9B,OAAO,IAAIJ,cAAc,UAAU;QACjCA,YAAY;IACd;IACA,OAAOA;AACT"}

node_modules/next/dist/shared/lib/router/utils/handle-smooth-scroll.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run function with `scroll-behavior: auto` applied to `<html/>`.
+ * This css change will be reverted after the function finishes.
+ */
+export declare function handleSmoothScroll(fn: () => void, options?: {
+    dontForceLayout?: boolean;
+    onlyHashChange?: boolean;
+}): void;

node_modules/next/dist/shared/lib/router/utils/handle-smooth-scroll.js

@@ -0,0 +1,35 @@
+/**
+ * Run function with `scroll-behavior: auto` applied to `<html/>`.
+ * This css change will be reverted after the function finishes.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "handleSmoothScroll", {
+    enumerable: true,
+    get: function() {
+        return handleSmoothScroll;
+    }
+});
+function handleSmoothScroll(fn, options) {
+    if (options === void 0) options = {};
+    // if only the hash is changed, we don't need to disable smooth scrolling
+    // we only care to prevent smooth scrolling when navigating to a new page to avoid jarring UX
+    if (options.onlyHashChange) {
+        fn();
+        return;
+    }
+    const htmlElement = document.documentElement;
+    const existing = htmlElement.style.scrollBehavior;
+    htmlElement.style.scrollBehavior = "auto";
+    if (!options.dontForceLayout) {
+        // In Chrome-based browsers we need to force reflow before calling `scrollTo`.
+        // Otherwise it will not pickup the change in scrollBehavior
+        // More info here: https://github.com/vercel/next.js/issues/40719#issuecomment-1336248042
+        htmlElement.getClientRects();
+    }
+    fn();
+    htmlElement.style.scrollBehavior = existing;
+}
+
+//# sourceMappingURL=handle-smooth-scroll.js.map

node_modules/next/dist/shared/lib/router/utils/handle-smooth-scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/handle-smooth-scroll.ts"],"names":["handleSmoothScroll","fn","options","onlyHashChange","htmlElement","document","documentElement","existing","style","scrollBehavior","dontForceLayout","getClientRects"],"mappings":"AAAA;;;CAGC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,mBACdC,EAAc,EACdC,OAAqE;IAArEA,IAAAA,oBAAAA,UAAmE,CAAC;IAEpE,yEAAyE;IACzE,6FAA6F;IAC7F,IAAIA,QAAQC,cAAc,EAAE;QAC1BF;QACA;IACF;IACA,MAAMG,cAAcC,SAASC,eAAe;IAC5C,MAAMC,WAAWH,YAAYI,KAAK,CAACC,cAAc;IACjDL,YAAYI,KAAK,CAACC,cAAc,GAAG;IACnC,IAAI,CAACP,QAAQQ,eAAe,EAAE;QAC5B,8EAA8E;QAC9E,4DAA4D;QAC5D,yFAAyF;QACzFN,YAAYO,cAAc;IAC5B;IACAV;IACAG,YAAYI,KAAK,CAACC,cAAc,GAAGF;AACrC"}

node_modules/next/dist/shared/lib/router/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { getSortedRoutes } from './sorted-routes';
+export { isDynamicRoute } from './is-dynamic';

node_modules/next/dist/shared/lib/router/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getSortedRoutes: null,
+    isDynamicRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getSortedRoutes: function() {
+        return _sortedroutes.getSortedRoutes;
+    },
+    isDynamicRoute: function() {
+        return _isdynamic.isDynamicRoute;
+    }
+});
+const _sortedroutes = require("./sorted-routes");
+const _isdynamic = require("./is-dynamic");
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/shared/lib/router/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/index.ts"],"names":["getSortedRoutes","isDynamicRoute"],"mappings":";;;;;;;;;;;;;;;IAASA,eAAe;eAAfA,6BAAe;;IACfC,cAAc;eAAdA,yBAAc;;;8BADS;2BACD"}

node_modules/next/dist/shared/lib/router/utils/interpolate-as.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'querystring';
+export declare function interpolateAs(route: string, asPathname: string, query: ParsedUrlQuery): {
+    params: string[];
+    result: string;
+};

node_modules/next/dist/shared/lib/router/utils/interpolate-as.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "interpolateAs", {
+    enumerable: true,
+    get: function() {
+        return interpolateAs;
+    }
+});
+const _routematcher = require("./route-matcher");
+const _routeregex = require("./route-regex");
+function interpolateAs(route, asPathname, query) {
+    let interpolatedRoute = "";
+    const dynamicRegex = (0, _routeregex.getRouteRegex)(route);
+    const dynamicGroups = dynamicRegex.groups;
+    const dynamicMatches = // Try to match the dynamic route against the asPath
+    (asPathname !== route ? (0, _routematcher.getRouteMatcher)(dynamicRegex)(asPathname) : "") || // Fall back to reading the values from the href
+    // TODO: should this take priority; also need to change in the router.
+    query;
+    interpolatedRoute = route;
+    const params = Object.keys(dynamicGroups);
+    if (!params.every((param)=>{
+        let value = dynamicMatches[param] || "";
+        const { repeat, optional } = dynamicGroups[param];
+        // support single-level catch-all
+        // TODO: more robust handling for user-error (passing `/`)
+        let replaced = "[" + (repeat ? "..." : "") + param + "]";
+        if (optional) {
+            replaced = (!value ? "/" : "") + "[" + replaced + "]";
+        }
+        if (repeat && !Array.isArray(value)) value = [
+            value
+        ];
+        return (optional || param in dynamicMatches) && // Interpolate group into data URL if present
+        (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(// these values should be fully encoded instead of just
+        // path delimiter escaped since they are being inserted
+        // into the URL and we expect URL encoded segments
+        // when parsing dynamic route params
+        (segment)=>encodeURIComponent(segment)).join("/") : encodeURIComponent(value)) || "/");
+    })) {
+        interpolatedRoute = "" // did not satisfy all requirements
+        ;
+    // n.b. We ignore this error because we handle warning for this case in
+    // development in the `<Link>` component directly.
+    }
+    return {
+        params,
+        result: interpolatedRoute
+    };
+}
+
+//# sourceMappingURL=interpolate-as.js.map

node_modules/next/dist/shared/lib/router/utils/interpolate-as.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/interpolate-as.ts"],"names":["interpolateAs","route","asPathname","query","interpolatedRoute","dynamicRegex","getRouteRegex","dynamicGroups","groups","dynamicMatches","getRouteMatcher","params","Object","keys","every","param","value","repeat","optional","replaced","Array","isArray","replace","map","segment","encodeURIComponent","join","result"],"mappings":";;;;+BAKgBA;;;eAAAA;;;8BAHgB;4BACF;AAEvB,SAASA,cACdC,KAAa,EACbC,UAAkB,EAClBC,KAAqB;IAErB,IAAIC,oBAAoB;IAExB,MAAMC,eAAeC,IAAAA,yBAAa,EAACL;IACnC,MAAMM,gBAAgBF,aAAaG,MAAM;IACzC,MAAMC,iBAEJ,AADA,oDAAoD;IACnDP,CAAAA,eAAeD,QAAQS,IAAAA,6BAAe,EAACL,cAAcH,cAAc,EAAC,KACrE,gDAAgD;IAChD,sEAAsE;IACtEC;IAEFC,oBAAoBH;IACpB,MAAMU,SAASC,OAAOC,IAAI,CAACN;IAE3B,IACE,CAACI,OAAOG,KAAK,CAAC,CAACC;QACb,IAAIC,QAAQP,cAAc,CAACM,MAAM,IAAI;QACrC,MAAM,EAAEE,MAAM,EAAEC,QAAQ,EAAE,GAAGX,aAAa,CAACQ,MAAM;QAEjD,iCAAiC;QACjC,0DAA0D;QAC1D,IAAII,WAAW,AAAC,MAAGF,CAAAA,SAAS,QAAQ,EAAC,IAAIF,QAAM;QAC/C,IAAIG,UAAU;YACZC,WAAW,AAAG,CAAA,CAACH,QAAQ,MAAM,EAAC,IAAE,MAAGG,WAAS;QAC9C;QACA,IAAIF,UAAU,CAACG,MAAMC,OAAO,CAACL,QAAQA,QAAQ;YAACA;SAAM;QAEpD,OACE,AAACE,CAAAA,YAAYH,SAASN,cAAa,KACnC,6CAA6C;QAC5CL,CAAAA,oBACCA,kBAAmBkB,OAAO,CACxBH,UACAF,SACI,AAACD,MACEO,GAAG,CACF,uDAAuD;QACvD,uDAAuD;QACvD,kDAAkD;QAClD,oCAAoC;QACpC,CAACC,UAAYC,mBAAmBD,UAEjCE,IAAI,CAAC,OACRD,mBAAmBT,WACpB,GAAE;IAEb,IACA;QACAZ,oBAAoB,GAAG,mCAAmC;;IAE1D,uEAAuE;IACvE,kDAAkD;IACpD;IACA,OAAO;QACLO;QACAgB,QAAQvB;IACV;AACF"}

node_modules/next/dist/shared/lib/router/utils/is-bot.d.ts

@@ -0,0 +1 @@
+export declare function isBot(userAgent: string): boolean;

node_modules/next/dist/shared/lib/router/utils/is-bot.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isBot", {
+    enumerable: true,
+    get: function() {
+        return isBot;
+    }
+});
+function isBot(userAgent) {
+    return /Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver/i.test(userAgent);
+}
+
+//# sourceMappingURL=is-bot.js.map

node_modules/next/dist/shared/lib/router/utils/is-bot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/is-bot.ts"],"names":["isBot","userAgent","test"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,MAAMC,SAAiB;IACrC,OAAO,oVAAoVC,IAAI,CAC7VD;AAEJ"}

node_modules/next/dist/shared/lib/router/utils/is-dynamic.d.ts

@@ -0,0 +1 @@
+export declare function isDynamicRoute(route: string): boolean;

node_modules/next/dist/shared/lib/router/utils/is-dynamic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isDynamicRoute", {
+    enumerable: true,
+    get: function() {
+        return isDynamicRoute;
+    }
+});
+const _interceptionroutes = require("../../../../server/future/helpers/interception-routes");
+// Identify /[param]/ in route string
+const TEST_ROUTE = /\/\[[^/]+?\](?=\/|$)/;
+function isDynamicRoute(route) {
+    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(route)) {
+        route = (0, _interceptionroutes.extractInterceptionRouteInformation)(route).interceptedRoute;
+    }
+    return TEST_ROUTE.test(route);
+}
+
+//# sourceMappingURL=is-dynamic.js.map

node_modules/next/dist/shared/lib/router/utils/is-dynamic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/is-dynamic.ts"],"names":["isDynamicRoute","TEST_ROUTE","route","isInterceptionRouteAppPath","extractInterceptionRouteInformation","interceptedRoute","test"],"mappings":";;;;+BAQgBA;;;eAAAA;;;oCALT;AAEP,qCAAqC;AACrC,MAAMC,aAAa;AAEZ,SAASD,eAAeE,KAAa;IAC1C,IAAIC,IAAAA,8CAA0B,EAACD,QAAQ;QACrCA,QAAQE,IAAAA,uDAAmC,EAACF,OAAOG,gBAAgB;IACrE;IAEA,OAAOJ,WAAWK,IAAI,CAACJ;AACzB"}

node_modules/next/dist/shared/lib/router/utils/is-local-url.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Detects whether a given url is routable by the Next.js router (browser only).
+ */
+export declare function isLocalURL(url: string): boolean;

node_modules/next/dist/shared/lib/router/utils/is-local-url.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isLocalURL", {
+    enumerable: true,
+    get: function() {
+        return isLocalURL;
+    }
+});
+const _utils = require("../../utils");
+const _hasbasepath = require("../../../../client/has-base-path");
+function isLocalURL(url) {
+    // prevent a hydration mismatch on href for url with anchor refs
+    if (!(0, _utils.isAbsoluteUrl)(url)) return true;
+    try {
+        // absolute urls can be local if they are on the same origin
+        const locationOrigin = (0, _utils.getLocationOrigin)();
+        const resolved = new URL(url, locationOrigin);
+        return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
+    } catch (_) {
+        return false;
+    }
+}
+
+//# sourceMappingURL=is-local-url.js.map

node_modules/next/dist/shared/lib/router/utils/is-local-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/is-local-url.ts"],"names":["isLocalURL","url","isAbsoluteUrl","locationOrigin","getLocationOrigin","resolved","URL","origin","hasBasePath","pathname","_"],"mappings":";;;;+BAMgBA;;;eAAAA;;;uBANiC;6BACrB;AAKrB,SAASA,WAAWC,GAAW;IACpC,gEAAgE;IAChE,IAAI,CAACC,IAAAA,oBAAa,EAACD,MAAM,OAAO;IAChC,IAAI;QACF,4DAA4D;QAC5D,MAAME,iBAAiBC,IAAAA,wBAAiB;QACxC,MAAMC,WAAW,IAAIC,IAAIL,KAAKE;QAC9B,OAAOE,SAASE,MAAM,KAAKJ,kBAAkBK,IAAAA,wBAAW,EAACH,SAASI,QAAQ;IAC5E,EAAE,OAAOC,GAAG;QACV,OAAO;IACT;AACF"}

node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.d.ts

@@ -0,0 +1,7 @@
+import type { BaseNextRequest } from '../../../../server/base-http';
+import type { MiddlewareMatcher } from '../../../../build/analysis/get-page-static-info';
+import type { Params } from './route-matcher';
+export interface MiddlewareRouteMatch {
+    (pathname: string | null | undefined, request: BaseNextRequest, query: Params): boolean;
+}
+export declare function getMiddlewareRouteMatcher(matchers: MiddlewareMatcher[]): MiddlewareRouteMatch;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getMiddlewareRouteMatcher", {
+    enumerable: true,
+    get: function() {
+        return getMiddlewareRouteMatcher;
+    }
+});
+const _preparedestination = require("./prepare-destination");
+function getMiddlewareRouteMatcher(matchers) {
+    return (pathname, req, query)=>{
+        for (const matcher of matchers){
+            const routeMatch = new RegExp(matcher.regexp).exec(pathname);
+            if (!routeMatch) {
+                continue;
+            }
+            if (matcher.has || matcher.missing) {
+                const hasParams = (0, _preparedestination.matchHas)(req, query, matcher.has, matcher.missing);
+                if (!hasParams) {
+                    continue;
+                }
+            }
+            return true;
+        }
+        return false;
+    };
+}
+
+//# sourceMappingURL=middleware-route-matcher.js.map

node_modules/next/dist/shared/lib/router/utils/middleware-route-matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/middleware-route-matcher.ts"],"names":["getMiddlewareRouteMatcher","matchers","pathname","req","query","matcher","routeMatch","RegExp","regexp","exec","has","missing","hasParams","matchHas"],"mappings":";;;;+BAagBA;;;eAAAA;;;oCAVS;AAUlB,SAASA,0BACdC,QAA6B;IAE7B,OAAO,CACLC,UACAC,KACAC;QAEA,KAAK,MAAMC,WAAWJ,SAAU;YAC9B,MAAMK,aAAa,IAAIC,OAAOF,QAAQG,MAAM,EAAEC,IAAI,CAACP;YACnD,IAAI,CAACI,YAAY;gBACf;YACF;YAEA,IAAID,QAAQK,GAAG,IAAIL,QAAQM,OAAO,EAAE;gBAClC,MAAMC,YAAYC,IAAAA,4BAAQ,EAACV,KAAKC,OAAOC,QAAQK,GAAG,EAAEL,QAAQM,OAAO;gBACnE,IAAI,CAACC,WAAW;oBACd;gBACF;YACF;YAEA,OAAO;QACT;QAEA,OAAO;IACT;AACF"}

node_modules/next/dist/shared/lib/router/utils/omit.d.ts

@@ -0,0 +1,3 @@
+export declare function omit<T extends {
+    [key: string]: unknown;
+}, K extends keyof T>(object: T, keys: K[]): Omit<T, K>;

node_modules/next/dist/shared/lib/router/utils/omit.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "omit", {
+    enumerable: true,
+    get: function() {
+        return omit;
+    }
+});
+function omit(object, keys) {
+    const omitted = {};
+    Object.keys(object).forEach((key)=>{
+        if (!keys.includes(key)) {
+            omitted[key] = object[key];
+        }
+    });
+    return omitted;
+}
+
+//# sourceMappingURL=omit.js.map

node_modules/next/dist/shared/lib/router/utils/omit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/omit.ts"],"names":["omit","object","keys","omitted","Object","forEach","key","includes"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA,KACdC,MAAS,EACTC,IAAS;IAET,MAAMC,UAAsC,CAAC;IAC7CC,OAAOF,IAAI,CAACD,QAAQI,OAAO,CAAC,CAACC;QAC3B,IAAI,CAACJ,KAAKK,QAAQ,CAACD,MAAW;YAC5BH,OAAO,CAACG,IAAI,GAAGL,MAAM,CAACK,IAAI;QAC5B;IACF;IACA,OAAOH;AACT"}

node_modules/next/dist/shared/lib/router/utils/parse-path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Given a path this function will find the pathname, query and hash and return
+ * them. This is useful to parse full paths on the client side.
+ * @param path A path to parse e.g. /foo/bar?id=1#hash
+ */
+export declare function parsePath(path: string): {
+    pathname: string;
+    query: string;
+    hash: string;
+};

node_modules/next/dist/shared/lib/router/utils/parse-path.js

@@ -0,0 +1,33 @@
+/**
+ * Given a path this function will find the pathname, query and hash and return
+ * them. This is useful to parse full paths on the client side.
+ * @param path A path to parse e.g. /foo/bar?id=1#hash
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parsePath", {
+    enumerable: true,
+    get: function() {
+        return parsePath;
+    }
+});
+function parsePath(path) {
+    const hashIndex = path.indexOf("#");
+    const queryIndex = path.indexOf("?");
+    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+    if (hasQuery || hashIndex > -1) {
+        return {
+            pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+            query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : "",
+            hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+        };
+    }
+    return {
+        pathname: path,
+        query: "",
+        hash: ""
+    };
+}
+
+//# sourceMappingURL=parse-path.js.map

node_modules/next/dist/shared/lib/router/utils/parse-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/parse-path.ts"],"names":["parsePath","path","hashIndex","indexOf","queryIndex","hasQuery","pathname","substring","query","undefined","hash","slice"],"mappings":"AAAA;;;;CAIC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,UAAUC,IAAY;IACpC,MAAMC,YAAYD,KAAKE,OAAO,CAAC;IAC/B,MAAMC,aAAaH,KAAKE,OAAO,CAAC;IAChC,MAAME,WAAWD,aAAa,CAAC,KAAMF,CAAAA,YAAY,KAAKE,aAAaF,SAAQ;IAE3E,IAAIG,YAAYH,YAAY,CAAC,GAAG;QAC9B,OAAO;YACLI,UAAUL,KAAKM,SAAS,CAAC,GAAGF,WAAWD,aAAaF;YACpDM,OAAOH,WACHJ,KAAKM,SAAS,CAACH,YAAYF,YAAY,CAAC,IAAIA,YAAYO,aACxD;YACJC,MAAMR,YAAY,CAAC,IAAID,KAAKU,KAAK,CAACT,aAAa;QACjD;IACF;IAEA,OAAO;QAAEI,UAAUL;QAAMO,OAAO;QAAIE,MAAM;IAAG;AAC/C"}

node_modules/next/dist/shared/lib/router/utils/parse-relative-url.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'querystring';
+export interface ParsedRelativeUrl {
+    hash: string;
+    href: string;
+    pathname: string;
+    query: ParsedUrlQuery;
+    search: string;
+}
+/**
+ * Parses path-relative urls (e.g. `/hello/world?foo=bar`). If url isn't path-relative
+ * (e.g. `./hello`) then at least base must be.
+ * Absolute urls are rejected with one exception, in the browser, absolute urls that are on
+ * the current origin will be parsed as relative
+ */
+export declare function parseRelativeUrl(url: string, base?: string): ParsedRelativeUrl;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseRelativeUrl", {
+    enumerable: true,
+    get: function() {
+        return parseRelativeUrl;
+    }
+});
+const _utils = require("../../utils");
+const _querystring = require("./querystring");
+function parseRelativeUrl(url, base) {
+    const globalBase = new URL(typeof window === "undefined" ? "http://n" : (0, _utils.getLocationOrigin)());
+    const resolvedBase = base ? new URL(base, globalBase) : url.startsWith(".") ? new URL(typeof window === "undefined" ? "http://n" : window.location.href) : globalBase;
+    const { pathname, searchParams, search, hash, href, origin } = new URL(url, resolvedBase);
+    if (origin !== globalBase.origin) {
+        throw new Error("invariant: invalid relative URL, router received " + url);
+    }
+    return {
+        pathname,
+        query: (0, _querystring.searchParamsToUrlQuery)(searchParams),
+        search,
+        hash,
+        href: href.slice(globalBase.origin.length)
+    };
+}
+
+//# sourceMappingURL=parse-relative-url.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/parse-relative-url.ts"],"names":["parseRelativeUrl","url","base","globalBase","URL","window","getLocationOrigin","resolvedBase","startsWith","location","href","pathname","searchParams","search","hash","origin","Error","query","searchParamsToUrlQuery","slice","length"],"mappings":";;;;+BAkBgBA;;;eAAAA;;;uBAjBkB;6BACK;AAgBhC,SAASA,iBACdC,GAAW,EACXC,IAAa;IAEb,MAAMC,aAAa,IAAIC,IACrB,OAAOC,WAAW,cAAc,aAAaC,IAAAA,wBAAiB;IAGhE,MAAMC,eAAeL,OACjB,IAAIE,IAAIF,MAAMC,cACdF,IAAIO,UAAU,CAAC,OACf,IAAIJ,IAAI,OAAOC,WAAW,cAAc,aAAaA,OAAOI,QAAQ,CAACC,IAAI,IACzEP;IAEJ,MAAM,EAAEQ,QAAQ,EAAEC,YAAY,EAAEC,MAAM,EAAEC,IAAI,EAAEJ,IAAI,EAAEK,MAAM,EAAE,GAAG,IAAIX,IACjEH,KACAM;IAEF,IAAIQ,WAAWZ,WAAWY,MAAM,EAAE;QAChC,MAAM,IAAIC,MAAM,AAAC,sDAAmDf;IACtE;IACA,OAAO;QACLU;QACAM,OAAOC,IAAAA,mCAAsB,EAACN;QAC9BC;QACAC;QACAJ,MAAMA,KAAKS,KAAK,CAAChB,WAAWY,MAAM,CAACK,MAAM;IAC3C;AACF"}

node_modules/next/dist/shared/lib/router/utils/parse-url.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'querystring';
+export interface ParsedUrl {
+    hash: string;
+    hostname?: string | null;
+    href: string;
+    pathname: string;
+    port?: string | null;
+    protocol?: string | null;
+    query: ParsedUrlQuery;
+    search: string;
+}
+export declare function parseUrl(url: string): ParsedUrl;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseUrl", {
+    enumerable: true,
+    get: function() {
+        return parseUrl;
+    }
+});
+const _querystring = require("./querystring");
+const _parserelativeurl = require("./parse-relative-url");
+function parseUrl(url) {
+    if (url.startsWith("/")) {
+        return (0, _parserelativeurl.parseRelativeUrl)(url);
+    }
+    const parsedURL = new URL(url);
+    return {
+        hash: parsedURL.hash,
+        hostname: parsedURL.hostname,
+        href: parsedURL.href,
+        pathname: parsedURL.pathname,
+        port: parsedURL.port,
+        protocol: parsedURL.protocol,
+        query: (0, _querystring.searchParamsToUrlQuery)(parsedURL.searchParams),
+        search: parsedURL.search
+    };
+}
+
+//# sourceMappingURL=parse-url.js.map

node_modules/next/dist/shared/lib/router/utils/parse-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/parse-url.ts"],"names":["parseUrl","url","startsWith","parseRelativeUrl","parsedURL","URL","hash","hostname","href","pathname","port","protocol","query","searchParamsToUrlQuery","searchParams","search"],"mappings":";;;;+BAgBgBA;;;eAAAA;;;6BAduB;kCACN;AAa1B,SAASA,SAASC,GAAW;IAClC,IAAIA,IAAIC,UAAU,CAAC,MAAM;QACvB,OAAOC,IAAAA,kCAAgB,EAACF;IAC1B;IAEA,MAAMG,YAAY,IAAIC,IAAIJ;IAC1B,OAAO;QACLK,MAAMF,UAAUE,IAAI;QACpBC,UAAUH,UAAUG,QAAQ;QAC5BC,MAAMJ,UAAUI,IAAI;QACpBC,UAAUL,UAAUK,QAAQ;QAC5BC,MAAMN,UAAUM,IAAI;QACpBC,UAAUP,UAAUO,QAAQ;QAC5BC,OAAOC,IAAAA,mCAAsB,EAACT,UAAUU,YAAY;QACpDC,QAAQX,UAAUW,MAAM;IAC1B;AACF"}

node_modules/next/dist/shared/lib/router/utils/path-has-prefix.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if a given path starts with a given prefix. It ensures it matches
+ * exactly without containing extra chars. e.g. prefix /docs should replace
+ * for /docs, /docs/, /docs/a but not /docsss
+ * @param path The path to check.
+ * @param prefix The prefix to check against.
+ */
+export declare function pathHasPrefix(path: string, prefix: string): boolean;

node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pathHasPrefix", {
+    enumerable: true,
+    get: function() {
+        return pathHasPrefix;
+    }
+});
+const _parsepath = require("./parse-path");
+function pathHasPrefix(path, prefix) {
+    if (typeof path !== "string") {
+        return false;
+    }
+    const { pathname } = (0, _parsepath.parsePath)(path);
+    return pathname === prefix || pathname.startsWith(prefix + "/");
+}
+
+//# sourceMappingURL=path-has-prefix.js.map

node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/path-has-prefix.ts"],"names":["pathHasPrefix","path","prefix","pathname","parsePath","startsWith"],"mappings":";;;;+BASgBA;;;eAAAA;;;2BATU;AASnB,SAASA,cAAcC,IAAY,EAAEC,MAAc;IACxD,IAAI,OAAOD,SAAS,UAAU;QAC5B,OAAO;IACT;IAEA,MAAM,EAAEE,QAAQ,EAAE,GAAGC,IAAAA,oBAAS,EAACH;IAC/B,OAAOE,aAAaD,UAAUC,SAASE,UAAU,CAACH,SAAS;AAC7D"}

node_modules/next/dist/shared/lib/router/utils/path-match.d.ts

@@ -0,0 +1,29 @@
+interface Options {
+    /**
+     * A transformer function that will be applied to the regexp generated
+     * from the provided path and path-to-regexp.
+     */
+    regexModifier?: (regex: string) => string;
+    /**
+     * When true the function will remove all unnamed parameters
+     * from the matched parameters.
+     */
+    removeUnnamedParams?: boolean;
+    /**
+     * When true the regexp won't allow an optional trailing delimiter
+     * to match.
+     */
+    strict?: boolean;
+    /**
+     * When true the matcher will be case-sensitive, defaults to false
+     */
+    sensitive?: boolean;
+}
+export type PatchMatcher = (pathname?: string | null, params?: Record<string, any>) => Record<string, any> | false;
+/**
+ * Generates a path matcher function for a given path and options based on
+ * path-to-regexp. By default the match will be case insensitive, non strict
+ * and delimited by `/`.
+ */
+export declare function getPathMatch(path: string, options?: Options): PatchMatcher;
+export {};

node_modules/next/dist/shared/lib/router/utils/path-match.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPathMatch", {
+    enumerable: true,
+    get: function() {
+        return getPathMatch;
+    }
+});
+const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
+function getPathMatch(path, options) {
+    const keys = [];
+    const regexp = (0, _pathtoregexp.pathToRegexp)(path, keys, {
+        delimiter: "/",
+        sensitive: typeof (options == null ? void 0 : options.sensitive) === "boolean" ? options.sensitive : false,
+        strict: options == null ? void 0 : options.strict
+    });
+    const matcher = (0, _pathtoregexp.regexpToFunction)((options == null ? void 0 : options.regexModifier) ? new RegExp(options.regexModifier(regexp.source), regexp.flags) : regexp, keys);
+    /**
+   * A matcher function that will check if a given pathname matches the path
+   * given in the builder function. When the path does not match it will return
+   * `false` but if it does it will return an object with the matched params
+   * merged with the params provided in the second argument.
+   */ return (pathname, params)=>{
+        // If no pathname is provided it's not a match.
+        if (typeof pathname !== "string") return false;
+        const match = matcher(pathname);
+        // If the path did not match `false` will be returned.
+        if (!match) return false;
+        /**
+     * If unnamed params are not allowed they must be removed from
+     * the matched parameters. path-to-regexp uses "string" for named and
+     * "number" for unnamed parameters.
+     */ if (options == null ? void 0 : options.removeUnnamedParams) {
+            for (const key of keys){
+                if (typeof key.name === "number") {
+                    delete match.params[key.name];
+                }
+            }
+        }
+        return {
+            ...params,
+            ...match.params
+        };
+    };
+}
+
+//# sourceMappingURL=path-match.js.map

node_modules/next/dist/shared/lib/router/utils/path-match.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/path-match.ts"],"names":["getPathMatch","path","options","keys","regexp","pathToRegexp","delimiter","sensitive","strict","matcher","regexpToFunction","regexModifier","RegExp","source","flags","pathname","params","match","removeUnnamedParams","key","name"],"mappings":";;;;+BAqCgBA;;;eAAAA;;;8BApCa;AAoCtB,SAASA,aAAaC,IAAY,EAAEC,OAAiB;IAC1D,MAAMC,OAAc,EAAE;IACtB,MAAMC,SAASC,IAAAA,0BAAY,EAACJ,MAAME,MAAM;QACtCG,WAAW;QACXC,WACE,QAAOL,2BAAAA,QAASK,SAAS,MAAK,YAAYL,QAAQK,SAAS,GAAG;QAChEC,MAAM,EAAEN,2BAAAA,QAASM,MAAM;IACzB;IAEA,MAAMC,UAAUC,IAAAA,8BAAgB,EAC9BR,CAAAA,2BAAAA,QAASS,aAAa,IAClB,IAAIC,OAAOV,QAAQS,aAAa,CAACP,OAAOS,MAAM,GAAGT,OAAOU,KAAK,IAC7DV,QACJD;IAGF;;;;;GAKC,GACD,OAAO,CAACY,UAAUC;QAChB,+CAA+C;QAC/C,IAAI,OAAOD,aAAa,UAAU,OAAO;QAEzC,MAAME,QAAQR,QAAQM;QAEtB,sDAAsD;QACtD,IAAI,CAACE,OAAO,OAAO;QAEnB;;;;KAIC,GACD,IAAIf,2BAAAA,QAASgB,mBAAmB,EAAE;YAChC,KAAK,MAAMC,OAAOhB,KAAM;gBACtB,IAAI,OAAOgB,IAAIC,IAAI,KAAK,UAAU;oBAChC,OAAOH,MAAMD,MAAM,CAACG,IAAIC,IAAI,CAAC;gBAC/B;YACF;QACF;QAEA,OAAO;YAAE,GAAGJ,MAAM;YAAE,GAAGC,MAAMD,MAAM;QAAC;IACtC;AACF"}

node_modules/next/dist/shared/lib/router/utils/prepare-destination.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import type { NextParsedUrlQuery } from '../../../../server/request-meta';
+import type { Params } from './route-matcher';
+import type { RouteHas } from '../../../../lib/load-custom-routes';
+import type { BaseNextRequest } from '../../../../server/base-http';
+export declare function matchHas(req: BaseNextRequest | IncomingMessage, query: Params, has?: RouteHas[], missing?: RouteHas[]): false | Params;
+export declare function compileNonPath(value: string, params: Params): string;
+export declare function prepareDestination(args: {
+    appendParamsToQuery: boolean;
+    destination: string;
+    params: Params;
+    query: NextParsedUrlQuery;
+}): {
+    newUrl: string;
+    destQuery: import("querystring").ParsedUrlQuery;
+    parsedDestination: import("./parse-url").ParsedUrl;
+};

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

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    compileNonPath: null,
+    matchHas: null,
+    prepareDestination: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    compileNonPath: function() {
+        return compileNonPath;
+    },
+    matchHas: function() {
+        return matchHas;
+    },
+    prepareDestination: function() {
+        return prepareDestination;
+    }
+});
+const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
+const _escaperegexp = require("../../escape-regexp");
+const _parseurl = require("./parse-url");
+const _interceptionroutes = require("../../../../server/future/helpers/interception-routes");
+const _approuterheaders = require("../../../../client/components/app-router-headers");
+const _getcookieparser = require("../../../../server/api-utils/get-cookie-parser");
+/**
+ * Ensure only a-zA-Z are used for param names for proper interpolating
+ * with path-to-regexp
+ */ function getSafeParamName(paramName) {
+    let newParamName = "";
+    for(let i = 0; i < paramName.length; i++){
+        const charCode = paramName.charCodeAt(i);
+        if (charCode > 64 && charCode < 91 || // A-Z
+        charCode > 96 && charCode < 123 // a-z
+        ) {
+            newParamName += paramName[i];
+        }
+    }
+    return newParamName;
+}
+function escapeSegment(str, segmentName) {
+    return str.replace(new RegExp(":" + (0, _escaperegexp.escapeStringRegexp)(segmentName), "g"), "__ESC_COLON_" + segmentName);
+}
+function unescapeSegments(str) {
+    return str.replace(/__ESC_COLON_/gi, ":");
+}
+function matchHas(req, query, has, missing) {
+    if (has === void 0) has = [];
+    if (missing === void 0) missing = [];
+    const params = {};
+    const hasMatch = (hasItem)=>{
+        let value;
+        let key = hasItem.key;
+        switch(hasItem.type){
+            case "header":
+                {
+                    key = key.toLowerCase();
+                    value = req.headers[key];
+                    break;
+                }
+            case "cookie":
+                {
+                    if ("cookies" in req) {
+                        value = req.cookies[hasItem.key];
+                    } else {
+                        const cookies = (0, _getcookieparser.getCookieParser)(req.headers)();
+                        value = cookies[hasItem.key];
+                    }
+                    break;
+                }
+            case "query":
+                {
+                    value = query[key];
+                    break;
+                }
+            case "host":
+                {
+                    const { host } = (req == null ? void 0 : req.headers) || {};
+                    // remove port from host if present
+                    const hostname = host == null ? void 0 : host.split(":", 1)[0].toLowerCase();
+                    value = hostname;
+                    break;
+                }
+            default:
+                {
+                    break;
+                }
+        }
+        if (!hasItem.value && value) {
+            params[getSafeParamName(key)] = value;
+            return true;
+        } else if (value) {
+            const matcher = new RegExp("^" + hasItem.value + "$");
+            const matches = Array.isArray(value) ? value.slice(-1)[0].match(matcher) : value.match(matcher);
+            if (matches) {
+                if (Array.isArray(matches)) {
+                    if (matches.groups) {
+                        Object.keys(matches.groups).forEach((groupKey)=>{
+                            params[groupKey] = matches.groups[groupKey];
+                        });
+                    } else if (hasItem.type === "host" && matches[0]) {
+                        params.host = matches[0];
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    };
+    const allMatch = has.every((item)=>hasMatch(item)) && !missing.some((item)=>hasMatch(item));
+    if (allMatch) {
+        return params;
+    }
+    return false;
+}
+function compileNonPath(value, params) {
+    if (!value.includes(":")) {
+        return value;
+    }
+    for (const key of Object.keys(params)){
+        if (value.includes(":" + key)) {
+            value = value.replace(new RegExp(":" + key + "\\*", "g"), ":" + key + "--ESCAPED_PARAM_ASTERISKS").replace(new RegExp(":" + key + "\\?", "g"), ":" + key + "--ESCAPED_PARAM_QUESTION").replace(new RegExp(":" + key + "\\+", "g"), ":" + key + "--ESCAPED_PARAM_PLUS").replace(new RegExp(":" + key + "(?!\\w)", "g"), "--ESCAPED_PARAM_COLON" + key);
+        }
+    }
+    value = value.replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, "\\$1").replace(/--ESCAPED_PARAM_PLUS/g, "+").replace(/--ESCAPED_PARAM_COLON/g, ":").replace(/--ESCAPED_PARAM_QUESTION/g, "?").replace(/--ESCAPED_PARAM_ASTERISKS/g, "*");
+    // the value needs to start with a forward-slash to be compiled
+    // correctly
+    return (0, _pathtoregexp.compile)("/" + value, {
+        validate: false
+    })(params).slice(1);
+}
+function prepareDestination(args) {
+    const query = Object.assign({}, args.query);
+    delete query.__nextLocale;
+    delete query.__nextDefaultLocale;
+    delete query.__nextDataReq;
+    delete query.__nextInferredLocaleFromDefault;
+    delete query[_approuterheaders.NEXT_RSC_UNION_QUERY];
+    let escapedDestination = args.destination;
+    for (const param of Object.keys({
+        ...args.params,
+        ...query
+    })){
+        escapedDestination = escapeSegment(escapedDestination, param);
+    }
+    const parsedDestination = (0, _parseurl.parseUrl)(escapedDestination);
+    const destQuery = parsedDestination.query;
+    const destPath = unescapeSegments("" + parsedDestination.pathname + (parsedDestination.hash || ""));
+    const destHostname = unescapeSegments(parsedDestination.hostname || "");
+    const destPathParamKeys = [];
+    const destHostnameParamKeys = [];
+    (0, _pathtoregexp.pathToRegexp)(destPath, destPathParamKeys);
+    (0, _pathtoregexp.pathToRegexp)(destHostname, destHostnameParamKeys);
+    const destParams = [];
+    destPathParamKeys.forEach((key)=>destParams.push(key.name));
+    destHostnameParamKeys.forEach((key)=>destParams.push(key.name));
+    const destPathCompiler = (0, _pathtoregexp.compile)(destPath, // we don't validate while compiling the destination since we should
+    // have already validated before we got to this point and validating
+    // breaks compiling destinations with named pattern params from the source
+    // e.g. /something:hello(.*) -> /another/:hello is broken with validation
+    // since compile validation is meant for reversing and not for inserting
+    // params from a separate path-regex into another
+    {
+        validate: false
+    });
+    const destHostnameCompiler = (0, _pathtoregexp.compile)(destHostname, {
+        validate: false
+    });
+    // update any params in query values
+    for (const [key, strOrArray] of Object.entries(destQuery)){
+        // the value needs to start with a forward-slash to be compiled
+        // correctly
+        if (Array.isArray(strOrArray)) {
+            destQuery[key] = strOrArray.map((value)=>compileNonPath(unescapeSegments(value), args.params));
+        } else if (typeof strOrArray === "string") {
+            destQuery[key] = compileNonPath(unescapeSegments(strOrArray), args.params);
+        }
+    }
+    // add path params to query if it's not a redirect and not
+    // already defined in destination query or path
+    let paramKeys = Object.keys(args.params).filter((name)=>name !== "nextInternalLocale");
+    if (args.appendParamsToQuery && !paramKeys.some((key)=>destParams.includes(key))) {
+        for (const key of paramKeys){
+            if (!(key in destQuery)) {
+                destQuery[key] = args.params[key];
+            }
+        }
+    }
+    let newUrl;
+    // The compiler also that the interception route marker is an unnamed param, hence '0',
+    // so we need to add it to the params object.
+    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(destPath)) {
+        for (const segment of destPath.split("/")){
+            const marker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+            if (marker) {
+                args.params["0"] = marker;
+                break;
+            }
+        }
+    }
+    try {
+        newUrl = destPathCompiler(args.params);
+        const [pathname, hash] = newUrl.split("#", 2);
+        parsedDestination.hostname = destHostnameCompiler(args.params);
+        parsedDestination.pathname = pathname;
+        parsedDestination.hash = "" + (hash ? "#" : "") + (hash || "");
+        delete parsedDestination.search;
+    } catch (err) {
+        if (err.message.match(/Expected .*? to not repeat, but got an array/)) {
+            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;
+    }
+    // Query merge order lowest priority to highest
+    // 1. initial URL query values
+    // 2. path segment values
+    // 3. destination specified query values
+    parsedDestination.query = {
+        ...query,
+        ...parsedDestination.query
+    };
+    return {
+        newUrl,
+        destQuery,
+        parsedDestination
+    };
+}
+
+//# sourceMappingURL=prepare-destination.js.map

node_modules/next/dist/shared/lib/router/utils/querystring.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { ParsedUrlQuery } from 'querystring';
+export declare function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery;
+export declare function urlQueryToSearchParams(urlQuery: ParsedUrlQuery): URLSearchParams;
+export declare function assign(target: URLSearchParams, ...searchParamsList: URLSearchParams[]): URLSearchParams;

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    assign: null,
+    searchParamsToUrlQuery: null,
+    urlQueryToSearchParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    assign: function() {
+        return assign;
+    },
+    searchParamsToUrlQuery: function() {
+        return searchParamsToUrlQuery;
+    },
+    urlQueryToSearchParams: function() {
+        return urlQueryToSearchParams;
+    }
+});
+function searchParamsToUrlQuery(searchParams) {
+    const query = {};
+    searchParams.forEach((value, key)=>{
+        if (typeof query[key] === "undefined") {
+            query[key] = value;
+        } else if (Array.isArray(query[key])) {
+            query[key].push(value);
+        } else {
+            query[key] = [
+                query[key],
+                value
+            ];
+        }
+    });
+    return query;
+}
+function stringifyUrlQueryParam(param) {
+    if (typeof param === "string" || typeof param === "number" && !isNaN(param) || typeof param === "boolean") {
+        return String(param);
+    } else {
+        return "";
+    }
+}
+function urlQueryToSearchParams(urlQuery) {
+    const result = new URLSearchParams();
+    Object.entries(urlQuery).forEach((param)=>{
+        let [key, value] = param;
+        if (Array.isArray(value)) {
+            value.forEach((item)=>result.append(key, stringifyUrlQueryParam(item)));
+        } else {
+            result.set(key, stringifyUrlQueryParam(value));
+        }
+    });
+    return result;
+}
+function assign(target) {
+    for(var _len = arguments.length, searchParamsList = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        searchParamsList[_key - 1] = arguments[_key];
+    }
+    searchParamsList.forEach((searchParams)=>{
+        Array.from(searchParams.keys()).forEach((key)=>target.delete(key));
+        searchParams.forEach((value, key)=>target.append(key, value));
+    });
+    return target;
+}
+
+//# sourceMappingURL=querystring.js.map

node_modules/next/dist/shared/lib/router/utils/querystring.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/querystring.ts"],"names":["assign","searchParamsToUrlQuery","urlQueryToSearchParams","searchParams","query","forEach","value","key","Array","isArray","push","stringifyUrlQueryParam","param","isNaN","String","urlQuery","result","URLSearchParams","Object","entries","item","append","set","target","searchParamsList","from","keys","delete"],"mappings":";;;;;;;;;;;;;;;;IA4CgBA,MAAM;eAANA;;IA1CAC,sBAAsB;eAAtBA;;IA4BAC,sBAAsB;eAAtBA;;;AA5BT,SAASD,uBACdE,YAA6B;IAE7B,MAAMC,QAAwB,CAAC;IAC/BD,aAAaE,OAAO,CAAC,CAACC,OAAOC;QAC3B,IAAI,OAAOH,KAAK,CAACG,IAAI,KAAK,aAAa;YACrCH,KAAK,CAACG,IAAI,GAAGD;QACf,OAAO,IAAIE,MAAMC,OAAO,CAACL,KAAK,CAACG,IAAI,GAAG;YAClCH,KAAK,CAACG,IAAI,CAAcG,IAAI,CAACJ;QACjC,OAAO;YACLF,KAAK,CAACG,IAAI,GAAG;gBAACH,KAAK,CAACG,IAAI;gBAAYD;aAAM;QAC5C;IACF;IACA,OAAOF;AACT;AAEA,SAASO,uBAAuBC,KAAc;IAC5C,IACE,OAAOA,UAAU,YAChB,OAAOA,UAAU,YAAY,CAACC,MAAMD,UACrC,OAAOA,UAAU,WACjB;QACA,OAAOE,OAAOF;IAChB,OAAO;QACL,OAAO;IACT;AACF;AAEO,SAASV,uBACda,QAAwB;IAExB,MAAMC,SAAS,IAAIC;IACnBC,OAAOC,OAAO,CAACJ,UAAUV,OAAO,CAAC;YAAC,CAACE,KAAKD,MAAM;QAC5C,IAAIE,MAAMC,OAAO,CAACH,QAAQ;YACxBA,MAAMD,OAAO,CAAC,CAACe,OAASJ,OAAOK,MAAM,CAACd,KAAKI,uBAAuBS;QACpE,OAAO;YACLJ,OAAOM,GAAG,CAACf,KAAKI,uBAAuBL;QACzC;IACF;IACA,OAAOU;AACT;AAEO,SAAShB,OACduB,MAAuB;IACvB,IAAA,IAAA,OAAA,UAAA,QAAA,AAAGC,mBAAH,UAAA,OAAA,IAAA,OAAA,QAAA,OAAA,GAAA,OAAA,MAAA;QAAGA,iBAAH,OAAA,KAAA,SAAA,CAAA,KAAsC;;IAEtCA,iBAAiBnB,OAAO,CAAC,CAACF;QACxBK,MAAMiB,IAAI,CAACtB,aAAauB,IAAI,IAAIrB,OAAO,CAAC,CAACE,MAAQgB,OAAOI,MAAM,CAACpB;QAC/DJ,aAAaE,OAAO,CAAC,CAACC,OAAOC,MAAQgB,OAAOF,MAAM,CAACd,KAAKD;IAC1D;IACA,OAAOiB;AACT"}

node_modules/next/dist/shared/lib/router/utils/relativize-url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given a URL as a string and a base URL it will make the URL relative
+ * if the parsed protocol and host is the same as the one in the base
+ * URL. Otherwise it returns the same URL string.
+ */
+export declare function relativizeURL(url: string | string, base: string | URL): string;

node_modules/next/dist/shared/lib/router/utils/relativize-url.js

@@ -0,0 +1,22 @@
+/**
+ * Given a URL as a string and a base URL it will make the URL relative
+ * if the parsed protocol and host is the same as the one in the base
+ * URL. Otherwise it returns the same URL string.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "relativizeURL", {
+    enumerable: true,
+    get: function() {
+        return relativizeURL;
+    }
+});
+function relativizeURL(url, base) {
+    const baseURL = typeof base === "string" ? new URL(base) : base;
+    const relative = new URL(url, base);
+    const origin = baseURL.protocol + "//" + baseURL.host;
+    return relative.protocol + "//" + relative.host === origin ? relative.toString().replace(origin, "") : relative.toString();
+}
+
+//# sourceMappingURL=relativize-url.js.map

node_modules/next/dist/shared/lib/router/utils/relativize-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/relativize-url.ts"],"names":["relativizeURL","url","base","baseURL","URL","relative","origin","protocol","host","toString","replace"],"mappings":"AAAA;;;;CAIC;;;;+BACeA;;;eAAAA;;;AAAT,SAASA,cAAcC,GAAoB,EAAEC,IAAkB;IACpE,MAAMC,UAAU,OAAOD,SAAS,WAAW,IAAIE,IAAIF,QAAQA;IAC3D,MAAMG,WAAW,IAAID,IAAIH,KAAKC;IAC9B,MAAMI,SAAS,AAAGH,QAAQI,QAAQ,GAAC,OAAIJ,QAAQK,IAAI;IACnD,OAAO,AAAGH,SAASE,QAAQ,GAAC,OAAIF,SAASG,IAAI,KAAOF,SAChDD,SAASI,QAAQ,GAAGC,OAAO,CAACJ,QAAQ,MACpCD,SAASI,QAAQ;AACvB"}

node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Given a path and a prefix it will remove the prefix when it exists in the
+ * given path. It ensures it matches exactly without containing extra chars
+ * and if the prefix is not there it will be noop.
+ *
+ * @param path The path to remove the prefix from.
+ * @param prefix The prefix to be removed.
+ */
+export declare function removePathPrefix(path: string, prefix: string): string;

node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removePathPrefix", {
+    enumerable: true,
+    get: function() {
+        return removePathPrefix;
+    }
+});
+const _pathhasprefix = require("./path-has-prefix");
+function removePathPrefix(path, prefix) {
+    // If the path doesn't start with the prefix we can return it as is. This
+    // protects us from situations where the prefix is a substring of the path
+    // prefix such as:
+    //
+    // For prefix: /blog
+    //
+    //   /blog -> true
+    //   /blog/ -> true
+    //   /blog/1 -> true
+    //   /blogging -> false
+    //   /blogging/ -> false
+    //   /blogging/1 -> false
+    if (!(0, _pathhasprefix.pathHasPrefix)(path, prefix)) {
+        return path;
+    }
+    // Remove the prefix from the path via slicing.
+    const withoutPrefix = path.slice(prefix.length);
+    // If the path without the prefix starts with a `/` we can return it as is.
+    if (withoutPrefix.startsWith("/")) {
+        return withoutPrefix;
+    }
+    // If the path without the prefix doesn't start with a `/` we need to add it
+    // back to the path to make sure it's a valid path.
+    return "/" + withoutPrefix;
+}
+
+//# sourceMappingURL=remove-path-prefix.js.map

node_modules/next/dist/shared/lib/router/utils/remove-path-prefix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/shared/lib/router/utils/remove-path-prefix.ts"],"names":["removePathPrefix","path","prefix","pathHasPrefix","withoutPrefix","slice","length","startsWith"],"mappings":";;;;+BAUgBA;;;eAAAA;;;+BAVc;AAUvB,SAASA,iBAAiBC,IAAY,EAAEC,MAAc;IAC3D,yEAAyE;IACzE,0EAA0E;IAC1E,kBAAkB;IAClB,EAAE;IACF,oBAAoB;IACpB,EAAE;IACF,kBAAkB;IAClB,mBAAmB;IACnB,oBAAoB;IACpB,uBAAuB;IACvB,wBAAwB;IACxB,yBAAyB;IACzB,IAAI,CAACC,IAAAA,4BAAa,EAACF,MAAMC,SAAS;QAChC,OAAOD;IACT;IAEA,+CAA+C;IAC/C,MAAMG,gBAAgBH,KAAKI,KAAK,CAACH,OAAOI,MAAM;IAE9C,2EAA2E;IAC3E,IAAIF,cAAcG,UAAU,CAAC,MAAM;QACjC,OAAOH;IACT;IAEA,4EAA4E;IAC5E,mDAAmD;IACnD,OAAO,AAAC,MAAGA;AACb"}

node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Removes the trailing slash for a given route or page path. Preserves the
+ * root page. Examples:
+ *   - `/foo/bar/` -> `/foo/bar`
+ *   - `/foo/bar` -> `/foo/bar`
+ *   - `/` -> `/`
+ */
+export declare function removeTrailingSlash(route: string): string;

node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -0,0 +1,21 @@
+/**
+ * Removes the trailing slash for a given route or page path. Preserves the
+ * root page. Examples:
+ *   - `/foo/bar/` -> `/foo/bar`
+ *   - `/foo/bar` -> `/foo/bar`
+ *   - `/` -> `/`
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "removeTrailingSlash", {
+    enumerable: true,
+    get: function() {
+        return removeTrailingSlash;
+    }
+});
+function removeTrailingSlash(route) {
+    return route.replace(/\/$/, "") || "/";
+}
+
+//# sourceMappingURL=remove-trailing-slash.js.map