feat(blog): add file-based blog with dynamic slugs, MDX content and layout shell

- Introduced blog routing using Next.js App Router
- Implemented dynamic [slug] pages for blog posts
- Added MDX-based content loading via lib/posts
- Integrated shared TopBar layout with navigation
- Established clear content, lib and component separation

apps/public-web/node_modules/next/dist/server/route-modules/pages/builtin/_error.d.ts

@@ -0,0 +1,5 @@
+import PagesRouteModule from '../module';
+export declare const routeModule: PagesRouteModule;
+export declare const handler: (req: import("http").IncomingMessage, res: import("http").ServerResponse, ctx: {
+    waitUntil: (prom: Promise<void>) => void;
+}) => Promise<void>;

apps/public-web/node_modules/next/dist/server/route-modules/pages/builtin/_error.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handler: null,
+    routeModule: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handler: function() {
+        return handler;
+    },
+    routeModule: function() {
+        return routeModule;
+    }
+});
+const _app = /*#__PURE__*/ _interop_require_default(require("../../../../pages/_app"));
+const _document = /*#__PURE__*/ _interop_require_default(require("../../../../pages/_document"));
+const _routekind = require("../../../route-kind");
+const _error = /*#__PURE__*/ _interop_require_wildcard(require("../../../../pages/_error"));
+const _module = /*#__PURE__*/ _interop_require_default(require("../module"));
+const _pageshandler = require("../pages-handler");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const routeModule = new _module.default({
+    // TODO: add descriptor for internal error page
+    definition: {
+        kind: _routekind.RouteKind.PAGES,
+        page: '/_error',
+        pathname: '/_error',
+        filename: '',
+        bundlePath: ''
+    },
+    distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+    relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',
+    components: {
+        App: _app.default,
+        Document: _document.default
+    },
+    userland: _error
+});
+const handler = (0, _pageshandler.getHandler)({
+    srcPage: '/_error',
+    routeModule,
+    userland: _error,
+    config: {},
+    isFallbackError: true
+});
+
+//# sourceMappingURL=_error.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/builtin/_error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/server/route-modules/pages/builtin/_error.tsx"],"sourcesContent":["import App from '../../../../pages/_app'\nimport Document from '../../../../pages/_document'\nimport { RouteKind } from '../../../route-kind'\n\nimport * as moduleError from '../../../../pages/_error'\n\nimport PagesRouteModule from '../module'\nimport { getHandler } from '../pages-handler'\n\nexport const routeModule = new PagesRouteModule({\n  // TODO: add descriptor for internal error page\n  definition: {\n    kind: RouteKind.PAGES,\n    page: '/_error',\n    pathname: '/_error',\n    filename: '',\n    bundlePath: '',\n  },\n  distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',\n  relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || '',\n  components: {\n    App,\n    Document,\n  },\n  userland: moduleError,\n})\n\nexport const handler = getHandler({\n  srcPage: '/_error',\n  routeModule,\n  userland: moduleError,\n  config: {},\n  isFallbackError: true,\n})\n"],"names":["handler","routeModule","PagesRouteModule","definition","kind","RouteKind","PAGES","page","pathname","filename","bundlePath","distDir","process","env","__NEXT_RELATIVE_DIST_DIR","relativeProjectDir","__NEXT_RELATIVE_PROJECT_DIR","components","App","Document","userland","moduleError","getHandler","srcPage","config","isFallbackError"],"mappings":";;;;;;;;;;;;;;;IA2BaA,OAAO;eAAPA;;IAlBAC,WAAW;eAAXA;;;4DATG;iEACK;2BACK;+DAEG;+DAEA;8BACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpB,MAAMA,cAAc,IAAIC,eAAgB,CAAC;IAC9C,+CAA+C;IAC/CC,YAAY;QACVC,MAAMC,oBAAS,CAACC,KAAK;QACrBC,MAAM;QACNC,UAAU;QACVC,UAAU;QACVC,YAAY;IACd;IACAC,SAASC,QAAQC,GAAG,CAACC,wBAAwB,IAAI;IACjDC,oBAAoBH,QAAQC,GAAG,CAACG,2BAA2B,IAAI;IAC/DC,YAAY;QACVC,KAAAA,YAAG;QACHC,UAAAA,iBAAQ;IACV;IACAC,UAAUC;AACZ;AAEO,MAAMrB,UAAUsB,IAAAA,wBAAU,EAAC;IAChCC,SAAS;IACTtB;IACAmB,UAAUC;IACVG,QAAQ,CAAC;IACTC,iBAAiB;AACnB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.compiled.d.ts

@@ -0,0 +1 @@
+export * from './module'

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.compiled.js

@@ -0,0 +1,20 @@
+"use strict";
+if (process.env.NEXT_RUNTIME === 'edge') {
+    module.exports = require('next/dist/server/route-modules/pages/module.js');
+} else {
+    if (process.env.NODE_ENV === 'development') {
+        if (process.env.TURBOPACK) {
+            module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.dev.js');
+        } else {
+            module.exports = require('next/dist/compiled/next-server/pages.runtime.dev.js');
+        }
+    } else {
+        if (process.env.TURBOPACK) {
+            module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.prod.js');
+        } else {
+            module.exports = require('next/dist/compiled/next-server/pages.runtime.prod.js');
+        }
+    }
+}
+
+//# sourceMappingURL=module.compiled.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.compiled.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/route-modules/pages/module.compiled.js"],"sourcesContent":["if (process.env.NEXT_RUNTIME === 'edge') {\n  module.exports = require('next/dist/server/route-modules/pages/module.js')\n} else {\n  if (process.env.NODE_ENV === 'development') {\n    if (process.env.TURBOPACK) {\n      module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.dev.js')\n    } else {\n      module.exports = require('next/dist/compiled/next-server/pages.runtime.dev.js')\n    }\n  } else {\n    if (process.env.TURBOPACK) {\n      module.exports = require('next/dist/compiled/next-server/pages-turbo.runtime.prod.js')\n    } else {\n      module.exports = require('next/dist/compiled/next-server/pages.runtime.prod.js')\n    }\n  }\n}\n"],"names":["process","env","NEXT_RUNTIME","module","exports","require","NODE_ENV","TURBOPACK"],"mappings":";AAAA,IAAIA,QAAQC,GAAG,CAACC,YAAY,KAAK,QAAQ;IACvCC,OAAOC,OAAO,GAAGC,QAAQ;AAC3B,OAAO;IACL,IAAIL,QAAQC,GAAG,CAACK,QAAQ,KAAK,eAAe;QAC1C,IAAIN,QAAQC,GAAG,CAACM,SAAS,EAAE;YACzBJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF,OAAO;QACL,IAAIL,QAAQC,GAAG,CAACM,SAAS,EAAE;YACzBJ,OAAOC,OAAO,GAAGC,QAAQ;QAC3B,OAAO;YACLF,OAAOC,OAAO,GAAGC,QAAQ;QAC3B;IACF;AACF","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.d.ts

@@ -0,0 +1,101 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { GetServerSideProps, GetStaticPaths, GetStaticProps, NextComponentType, PageConfig } from '../../../types';
+import type { PagesRouteDefinition } from '../../route-definitions/pages-route-definition';
+import type { NextParsedUrlQuery } from '../../request-meta';
+import type { PagesRenderContext, PagesSharedContext, RenderOpts } from '../../render';
+import type RenderResult from '../../render-result';
+import type { AppType, DocumentType } from '../../../shared/lib/utils';
+import { RouteModule, type RouteModuleHandleContext, type RouteModuleOptions } from '../route-module';
+import { renderToHTML } from '../../render';
+import * as vendoredContexts from './vendored/contexts/entrypoints';
+/**
+ * The PagesModule is the type of the module exported by the bundled pages
+ * module.
+ */
+export type PagesModule = typeof import('../../../build/templates/pages');
+/**
+ * The userland module for a page. This is the module that is exported from the
+ * page file that contains the page component, page config, and any page data
+ * fetching functions.
+ */
+export type PagesUserlandModule = {
+    /**
+     * The exported page component.
+     */
+    readonly default: NextComponentType;
+    /**
+     * The exported page config.
+     */
+    readonly config?: PageConfig;
+    /**
+     * The exported `getStaticProps` function.
+     */
+    readonly getStaticProps?: GetStaticProps;
+    /**
+     * The exported `getStaticPaths` function.
+     */
+    readonly getStaticPaths?: GetStaticPaths;
+    /**
+     * The exported `getServerSideProps` function.
+     */
+    readonly getServerSideProps?: GetServerSideProps;
+};
+/**
+ * The components that are used to render a page. These aren't tied to the
+ * specific page being rendered, but rather are the components that are used to
+ * render all pages.
+ */
+type PagesComponents = {
+    /**
+     * The `App` component. This could be exported by a user's custom `_app` page
+     * file, or it could be the default `App` component.
+     */
+    readonly App: AppType;
+    /**
+     * The `Document` component. This could be exported by a user's custom
+     * `_document` page file, or it could be the default `Document` component.
+     */
+    readonly Document: DocumentType;
+};
+export interface PagesRouteModuleOptions extends RouteModuleOptions<PagesRouteDefinition, PagesUserlandModule> {
+    readonly components: PagesComponents;
+}
+/**
+ * AppRouteRouteHandlerContext is the context that is passed to the route
+ * handler for app routes.
+ */
+export interface PagesRouteHandlerContext extends RouteModuleHandleContext {
+    /**
+     * The page for the given route.
+     */
+    page: string;
+    /**
+     * The parsed URL query for the given request.
+     */
+    query: NextParsedUrlQuery;
+    /**
+     * The shared context used for all page renders.
+     */
+    sharedContext: PagesSharedContext;
+    /**
+     * The context for the given request.
+     */
+    renderContext: PagesRenderContext;
+    /**
+     * The arguments for the given request.
+    /**
+     * The RenderOpts for the given request which include the specific modules to
+     * use for rendering.
+     */
+    renderOpts: Omit<RenderOpts, 'Document' | 'App'>;
+}
+export declare class PagesRouteModule extends RouteModule<PagesRouteDefinition, PagesUserlandModule> {
+    private readonly components;
+    constructor(options: PagesRouteModuleOptions);
+    render(req: IncomingMessage, res: ServerResponse, context: PagesRouteHandlerContext): Promise<RenderResult>;
+}
+declare const vendored: {
+    contexts: typeof vendoredContexts;
+};
+export { renderToHTML, vendored };
+export default PagesRouteModule;

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PagesRouteModule: null,
+    default: null,
+    renderToHTML: null,
+    vendored: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PagesRouteModule: function() {
+        return PagesRouteModule;
+    },
+    default: function() {
+        return _default;
+    },
+    renderToHTML: function() {
+        return _render.renderToHTML;
+    },
+    vendored: function() {
+        return vendored;
+    }
+});
+const _routemodule = require("../route-module");
+const _render = require("../../render");
+const _entrypoints = /*#__PURE__*/ _interop_require_wildcard(require("./vendored/contexts/entrypoints"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class PagesRouteModule extends _routemodule.RouteModule {
+    constructor(options){
+        super(options);
+        this.components = options.components;
+    }
+    render(req, res, context) {
+        return (0, _render.renderToHTMLImpl)(req, res, context.page, context.query, context.renderOpts, {
+            App: this.components.App,
+            Document: this.components.Document
+        }, context.sharedContext, context.renderContext);
+    }
+}
+const vendored = {
+    contexts: _entrypoints
+};
+const _default = PagesRouteModule;
+
+//# sourceMappingURL=module.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.render.d.ts

@@ -0,0 +1,2 @@
+import type { PagesRender } from '../../render';
+export declare const lazyRenderPagesPage: PagesRender;

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.render.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "lazyRenderPagesPage", {
+    enumerable: true,
+    get: function() {
+        return lazyRenderPagesPage;
+    }
+});
+const lazyRenderPagesPage = (...args)=>{
+    if (process.env.NEXT_MINIMAL) {
+        throw Object.defineProperty(new Error("Can't use lazyRenderPagesPage in minimal mode"), "__NEXT_ERROR_CODE", {
+            value: "E272",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        const render = require('./module.compiled').renderToHTML;
+        return render(...args);
+    }
+};
+
+//# sourceMappingURL=module.render.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/module.render.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/route-modules/pages/module.render.ts"],"sourcesContent":["import type { PagesRender } from '../../render'\n\nexport const lazyRenderPagesPage: PagesRender = (...args) => {\n  if (process.env.NEXT_MINIMAL) {\n    throw new Error(\"Can't use lazyRenderPagesPage in minimal mode\")\n  } else {\n    const render: PagesRender = (\n      require('./module.compiled') as typeof import('./module.compiled')\n    ).renderToHTML\n\n    return render(...args)\n  }\n}\n"],"names":["lazyRenderPagesPage","args","process","env","NEXT_MINIMAL","Error","render","require","renderToHTML"],"mappings":";;;;+BAEaA;;;eAAAA;;;AAAN,MAAMA,sBAAmC,CAAC,GAAGC;IAClD,IAAIC,QAAQC,GAAG,CAACC,YAAY,EAAE;QAC5B,MAAM,qBAA0D,CAA1D,IAAIC,MAAM,kDAAV,qBAAA;mBAAA;wBAAA;0BAAA;QAAyD;IACjE,OAAO;QACL,MAAMC,SAAsB,AAC1BC,QAAQ,qBACRC,YAAY;QAEd,OAAOF,UAAUL;IACnB;AACF","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/pages-handler.d.ts

@@ -0,0 +1,15 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { PagesRouteModule } from './module.compiled';
+import type { GetServerSideProps, GetStaticPaths, GetStaticProps } from '../../../types';
+export declare const getHandler: ({ srcPage: originalSrcPage, config, userland, routeModule, isFallbackError, getStaticPaths, getStaticProps, getServerSideProps, }: {
+    srcPage: string;
+    config: Record<string, any> | undefined;
+    userland: any;
+    isFallbackError?: boolean;
+    routeModule: PagesRouteModule;
+    getStaticProps?: GetStaticProps;
+    getStaticPaths?: GetStaticPaths;
+    getServerSideProps?: GetServerSideProps;
+}) => (req: IncomingMessage, res: ServerResponse, ctx: {
+    waitUntil: (prom: Promise<void>) => void;
+}) => Promise<void>;

apps/public-web/node_modules/next/dist/server/route-modules/pages/pages-handler.js

@@ -0,0 +1,522 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getHandler", {
+    enumerable: true,
+    get: function() {
+        return getHandler;
+    }
+});
+const _routekind = require("../../route-kind");
+const _constants = require("../../lib/trace/constants");
+const _tracer = require("../../lib/trace/tracer");
+const _formaturl = require("../../../shared/lib/router/utils/format-url");
+const _requestmeta = require("../../request-meta");
+const _interopdefault = require("../../app-render/interop-default");
+const _utils = require("../../instrumentation/utils");
+const _normalizedatapath = require("../../../shared/lib/page-path/normalize-data-path");
+const _responsecache = require("../../response-cache");
+const _cachecontrol = require("../../lib/cache-control");
+const _utils1 = require("../../../shared/lib/utils");
+const _redirectstatus = require("../../../lib/redirect-status");
+const _constants1 = require("../../../lib/constants");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _sendpayload = require("../../send-payload");
+const _renderresult = /*#__PURE__*/ _interop_require_default(require("../../render-result"));
+const _utils2 = require("../../response-cache/utils");
+const _nofallbackerrorexternal = require("../../../shared/lib/no-fallback-error.external");
+const _redirectstatuscode = require("../../../client/components/redirect-status-code");
+const _isbot = require("../../../shared/lib/router/utils/is-bot");
+const _addpathprefix = require("../../../shared/lib/router/utils/add-path-prefix");
+const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
+const _deploymentid = require("../../../shared/lib/deployment-id");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, isFallbackError, getStaticPaths, getStaticProps, getServerSideProps })=>{
+    return async function handler(req, res, ctx) {
+        var _serverFilesManifest_config_experimental, _serverFilesManifest_config;
+        if (routeModule.isDev) {
+            (0, _requestmeta.addRequestMeta)(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint());
+        }
+        let srcPage = originalSrcPage;
+        // turbopack doesn't normalize `/index` in the page name
+        // so we need to to process dynamic routes properly
+        // TODO: fix turbopack providing differing value from webpack
+        if (process.env.TURBOPACK) {
+            srcPage = srcPage.replace(/\/index$/, '') || '/';
+        } else if (srcPage === '/index') {
+            // we always normalize /index specifically
+            srcPage = '/';
+        }
+        const multiZoneDraftMode = process.env.__NEXT_MULTI_ZONE_DRAFT_MODE;
+        const prepareResult = await routeModule.prepare(req, res, {
+            srcPage,
+            multiZoneDraftMode
+        });
+        if (!prepareResult) {
+            res.statusCode = 400;
+            res.end('Bad Request');
+            ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
+            return;
+        }
+        const isMinimalMode = Boolean(process.env.MINIMAL_MODE || (0, _requestmeta.getRequestMeta)(req, 'minimalMode'));
+        const render404 = async ()=>{
+            // TODO: should route-module itself handle rendering the 404
+            if (routerServerContext == null ? void 0 : routerServerContext.render404) {
+                await routerServerContext.render404(req, res, parsedUrl, false);
+            } else {
+                res.end('This page could not be found');
+            }
+        };
+        const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname } = prepareResult;
+        const isExperimentalCompile = serverFilesManifest == null ? void 0 : (_serverFilesManifest_config = serverFilesManifest.config) == null ? void 0 : (_serverFilesManifest_config_experimental = _serverFilesManifest_config.experimental) == null ? void 0 : _serverFilesManifest_config_experimental.isExperimentalCompile;
+        const hasServerProps = Boolean(getServerSideProps);
+        const hasStaticProps = Boolean(getStaticProps);
+        const hasStaticPaths = Boolean(getStaticPaths);
+        const hasGetInitialProps = Boolean((userland.default || userland).getInitialProps);
+        let cacheKey = null;
+        let isIsrFallback = false;
+        let isNextDataRequest = prepareResult.isNextDataRequest && (hasStaticProps || hasServerProps);
+        const is404Page = srcPage === '/404';
+        const is500Page = srcPage === '/500';
+        const isErrorPage = srcPage === '/_error';
+        if (!routeModule.isDev && !isDraftMode && hasStaticProps) {
+            cacheKey = `${locale ? `/${locale}` : ''}${(srcPage === '/' || resolvedPathname === '/') && locale ? '' : resolvedPathname}`;
+            if (is404Page || is500Page || isErrorPage) {
+                cacheKey = `${locale ? `/${locale}` : ''}${srcPage}`;
+            }
+            // ensure /index and / is normalized to one key
+            cacheKey = cacheKey === '/index' ? '/' : cacheKey;
+        }
+        if (hasStaticPaths && !isDraftMode) {
+            const decodedPathname = (0, _removetrailingslash.removeTrailingSlash)(locale ? (0, _addpathprefix.addPathPrefix)(resolvedPathname, `/${locale}`) : resolvedPathname);
+            const isPrerendered = Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname);
+            const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage];
+            if (prerenderInfo) {
+                if (prerenderInfo.fallback === false && !isPrerendered) {
+                    if (nextConfig.experimental.adapterPath) {
+                        return await render404();
+                    }
+                    throw new _nofallbackerrorexternal.NoFallbackError();
+                }
+                if (typeof prerenderInfo.fallback === 'string' && !isPrerendered && !isNextDataRequest) {
+                    isIsrFallback = true;
+                }
+            }
+        }
+        // When serving a bot request, we want to serve a blocking render and not
+        // the prerendered page. This ensures that the correct content is served
+        // to the bot in the head.
+        if (isIsrFallback && (0, _isbot.isBot)(req.headers['user-agent'] || '') || isMinimalMode) {
+            isIsrFallback = false;
+        }
+        const tracer = (0, _tracer.getTracer)();
+        const activeSpan = tracer.getActiveScopeSpan();
+        try {
+            var _parsedUrl_pathname;
+            const method = req.method || 'GET';
+            const resolvedUrl = (0, _formaturl.formatUrl)({
+                pathname: nextConfig.trailingSlash ? `${encodedResolvedPathname}${!encodedResolvedPathname.endsWith('/') && ((_parsedUrl_pathname = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname.endsWith('/')) ? '/' : ''}` : (0, _removetrailingslash.removeTrailingSlash)(encodedResolvedPathname || '/'),
+                // make sure to only add query values from original URL
+                query: hasStaticProps ? {} : originalQuery
+            });
+            const handleResponse = async (span)=>{
+                const responseGenerator = async ({ previousCacheEntry })=>{
+                    var _previousCacheEntry_value;
+                    const doRender = async ()=>{
+                        try {
+                            var _nextConfig_i18n;
+                            return await routeModule.render(req, res, {
+                                query: hasStaticProps && !isExperimentalCompile ? {
+                                    ...params
+                                } : {
+                                    ...query,
+                                    ...params
+                                },
+                                params,
+                                page: srcPage,
+                                renderContext: {
+                                    isDraftMode,
+                                    isFallback: isIsrFallback,
+                                    developmentNotFoundSourcePage: (0, _requestmeta.getRequestMeta)(req, 'developmentNotFoundSourcePage')
+                                },
+                                sharedContext: {
+                                    buildId,
+                                    customServer: Boolean(routerServerContext == null ? void 0 : routerServerContext.isCustomServer) || undefined,
+                                    deploymentId: (0, _deploymentid.getDeploymentId)()
+                                },
+                                renderOpts: {
+                                    params,
+                                    routeModule,
+                                    page: srcPage,
+                                    pageConfig: config || {},
+                                    Component: (0, _interopdefault.interopDefault)(userland),
+                                    ComponentMod: userland,
+                                    getStaticProps,
+                                    getStaticPaths,
+                                    getServerSideProps,
+                                    supportsDynamicResponse: !hasStaticProps,
+                                    buildManifest: isFallbackError ? fallbackBuildManifest : buildManifest,
+                                    nextFontManifest,
+                                    reactLoadableManifest,
+                                    assetPrefix: nextConfig.assetPrefix,
+                                    previewProps: prerenderManifest.preview,
+                                    images: nextConfig.images,
+                                    nextConfigOutput: nextConfig.output,
+                                    optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
+                                    nextScriptWorkers: Boolean(nextConfig.experimental.nextScriptWorkers),
+                                    domainLocales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.domains,
+                                    crossOrigin: nextConfig.crossOrigin,
+                                    multiZoneDraftMode,
+                                    basePath: nextConfig.basePath,
+                                    disableOptimizedLoading: nextConfig.experimental.disableOptimizedLoading,
+                                    largePageDataBytes: nextConfig.experimental.largePageDataBytes,
+                                    isExperimentalCompile,
+                                    experimental: {
+                                        clientTraceMetadata: nextConfig.experimental.clientTraceMetadata || []
+                                    },
+                                    locale,
+                                    locales,
+                                    defaultLocale,
+                                    setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
+                                    isNextDataRequest: isNextDataRequest && (hasServerProps || hasStaticProps),
+                                    resolvedUrl,
+                                    // For getServerSideProps and getInitialProps we need to ensure we use the original URL
+                                    // and not the resolved URL to prevent a hydration mismatch on
+                                    // asPath
+                                    resolvedAsPath: hasServerProps || hasGetInitialProps ? (0, _formaturl.formatUrl)({
+                                        // we use the original URL pathname less the _next/data prefix if
+                                        // present
+                                        pathname: isNextDataRequest ? (0, _normalizedatapath.normalizeDataPath)(originalPathname) : originalPathname,
+                                        query: originalQuery
+                                    }) : resolvedUrl,
+                                    isOnDemandRevalidate,
+                                    ErrorDebug: (0, _requestmeta.getRequestMeta)(req, 'PagesErrorDebug'),
+                                    err: (0, _requestmeta.getRequestMeta)(req, 'invokeError'),
+                                    dev: routeModule.isDev,
+                                    // needed for experimental.optimizeCss feature
+                                    distDir: _path.default.join(/* turbopackIgnore: true */ process.cwd(), routeModule.relativeProjectDir, routeModule.distDir)
+                                }
+                            }).then((renderResult)=>{
+                                const { metadata } = renderResult;
+                                let cacheControl = metadata.cacheControl;
+                                if ('isNotFound' in metadata && metadata.isNotFound) {
+                                    return {
+                                        value: null,
+                                        cacheControl
+                                    };
+                                }
+                                // Handle `isRedirect`.
+                                if (metadata.isRedirect) {
+                                    return {
+                                        value: {
+                                            kind: _responsecache.CachedRouteKind.REDIRECT,
+                                            props: metadata.pageData ?? metadata.flightData
+                                        },
+                                        cacheControl
+                                    };
+                                }
+                                return {
+                                    value: {
+                                        kind: _responsecache.CachedRouteKind.PAGES,
+                                        html: renderResult,
+                                        pageData: renderResult.metadata.pageData,
+                                        headers: renderResult.metadata.headers,
+                                        status: renderResult.metadata.statusCode
+                                    },
+                                    cacheControl
+                                };
+                            }).finally(()=>{
+                                if (!span) return;
+                                span.setAttributes({
+                                    'http.status_code': res.statusCode,
+                                    'next.rsc': false
+                                });
+                                const rootSpanAttributes = tracer.getRootSpanAttributes();
+                                // We were unable to get attributes, probably OTEL is not enabled
+                                if (!rootSpanAttributes) {
+                                    return;
+                                }
+                                if (rootSpanAttributes.get('next.span_type') !== _constants.BaseServerSpan.handleRequest) {
+                                    console.warn(`Unexpected root span type '${rootSpanAttributes.get('next.span_type')}'. Please report this Next.js issue https://github.com/vercel/next.js`);
+                                    return;
+                                }
+                                const route = rootSpanAttributes.get('next.route');
+                                if (route) {
+                                    const name = `${method} ${route}`;
+                                    span.setAttributes({
+                                        'next.route': route,
+                                        'http.route': route,
+                                        'next.span_name': name
+                                    });
+                                    span.updateName(name);
+                                } else {
+                                    span.updateName(`${method} ${srcPage}`);
+                                }
+                            });
+                        } catch (err) {
+                            // if this is a background revalidate we need to report
+                            // the request error here as it won't be bubbled
+                            if (previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) {
+                                const silenceLog = false;
+                                await routeModule.onRequestError(req, err, {
+                                    routerKind: 'Pages Router',
+                                    routePath: srcPage,
+                                    routeType: 'render',
+                                    revalidateReason: (0, _utils.getRevalidateReason)({
+                                        isStaticGeneration: hasStaticProps,
+                                        isOnDemandRevalidate
+                                    })
+                                }, silenceLog, routerServerContext);
+                            }
+                            throw err;
+                        }
+                    };
+                    // if we've already generated this page we no longer
+                    // serve the fallback
+                    if (previousCacheEntry) {
+                        isIsrFallback = false;
+                    }
+                    if (isIsrFallback) {
+                        const fallbackResponse = await routeModule.getResponseCache(req).get(routeModule.isDev ? null : locale ? `/${locale}${srcPage}` : srcPage, async ({ previousCacheEntry: previousFallbackCacheEntry = null })=>{
+                            if (!routeModule.isDev) {
+                                return (0, _utils2.toResponseCacheEntry)(previousFallbackCacheEntry);
+                            }
+                            return doRender();
+                        }, {
+                            routeKind: _routekind.RouteKind.PAGES,
+                            isFallback: true,
+                            isRoutePPREnabled: false,
+                            isOnDemandRevalidate: false,
+                            incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode),
+                            waitUntil: ctx.waitUntil
+                        });
+                        if (fallbackResponse) {
+                            // Remove the cache control from the response to prevent it from being
+                            // used in the surrounding cache.
+                            delete fallbackResponse.cacheControl;
+                            fallbackResponse.isMiss = true;
+                            return fallbackResponse;
+                        }
+                    }
+                    if (!isMinimalMode && isOnDemandRevalidate && revalidateOnlyGenerated && !previousCacheEntry) {
+                        res.statusCode = 404;
+                        // on-demand revalidate always sets this header
+                        res.setHeader('x-nextjs-cache', 'REVALIDATED');
+                        res.end('This page could not be found');
+                        return null;
+                    }
+                    if (isIsrFallback && (previousCacheEntry == null ? void 0 : (_previousCacheEntry_value = previousCacheEntry.value) == null ? void 0 : _previousCacheEntry_value.kind) === _responsecache.CachedRouteKind.PAGES) {
+                        return {
+                            value: {
+                                kind: _responsecache.CachedRouteKind.PAGES,
+                                html: new _renderresult.default(Buffer.from(previousCacheEntry.value.html), {
+                                    contentType: _constants1.HTML_CONTENT_TYPE_HEADER,
+                                    metadata: {
+                                        statusCode: previousCacheEntry.value.status,
+                                        headers: previousCacheEntry.value.headers
+                                    }
+                                }),
+                                pageData: {},
+                                status: previousCacheEntry.value.status,
+                                headers: previousCacheEntry.value.headers
+                            },
+                            cacheControl: {
+                                revalidate: 0,
+                                expire: undefined
+                            }
+                        };
+                    }
+                    return doRender();
+                };
+                const result = await routeModule.handleResponse({
+                    cacheKey,
+                    req,
+                    nextConfig,
+                    routeKind: _routekind.RouteKind.PAGES,
+                    isOnDemandRevalidate,
+                    revalidateOnlyGenerated,
+                    waitUntil: ctx.waitUntil,
+                    responseGenerator: responseGenerator,
+                    prerenderManifest,
+                    isMinimalMode
+                });
+                // if we got a cache hit this wasn't an ISR fallback
+                // but it wasn't generated during build so isn't in the
+                // prerender-manifest
+                if (isIsrFallback && !(result == null ? void 0 : result.isMiss)) {
+                    isIsrFallback = false;
+                }
+                // response is finished is no cache entry
+                if (!result) {
+                    return;
+                }
+                if (hasStaticProps && !isMinimalMode) {
+                    res.setHeader('x-nextjs-cache', isOnDemandRevalidate ? 'REVALIDATED' : result.isMiss ? 'MISS' : result.isStale ? 'STALE' : 'HIT');
+                }
+                let cacheControl;
+                if (!hasStaticProps || isIsrFallback) {
+                    if (!res.getHeader('Cache-Control')) {
+                        cacheControl = {
+                            revalidate: 0,
+                            expire: undefined
+                        };
+                    }
+                } else if (is404Page) {
+                    const notFoundRevalidate = (0, _requestmeta.getRequestMeta)(req, 'notFoundRevalidate');
+                    cacheControl = {
+                        revalidate: typeof notFoundRevalidate === 'undefined' ? 0 : notFoundRevalidate,
+                        expire: undefined
+                    };
+                } else if (is500Page) {
+                    cacheControl = {
+                        revalidate: 0,
+                        expire: undefined
+                    };
+                } else if (result.cacheControl) {
+                    // If the cache entry has a cache control with a revalidate value that's
+                    // a number, use it.
+                    if (typeof result.cacheControl.revalidate === 'number') {
+                        var _result_cacheControl;
+                        if (result.cacheControl.revalidate < 1) {
+                            throw Object.defineProperty(new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`), "__NEXT_ERROR_CODE", {
+                                value: "E22",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        cacheControl = {
+                            revalidate: result.cacheControl.revalidate,
+                            expire: ((_result_cacheControl = result.cacheControl) == null ? void 0 : _result_cacheControl.expire) ?? nextConfig.expireTime
+                        };
+                    } else {
+                        // revalidate: false
+                        cacheControl = {
+                            revalidate: _constants1.CACHE_ONE_YEAR,
+                            expire: undefined
+                        };
+                    }
+                }
+                // If cache control is already set on the response we don't
+                // override it to allow users to customize it via next.config
+                if (cacheControl && !res.getHeader('Cache-Control')) {
+                    res.setHeader('Cache-Control', (0, _cachecontrol.getCacheControlHeader)(cacheControl));
+                }
+                // notFound: true case
+                if (!result.value) {
+                    var _result_cacheControl1;
+                    // add revalidate metadata before rendering 404 page
+                    // so that we can use this as source of truth for the
+                    // cache-control header instead of what the 404 page returns
+                    // for the revalidate value
+                    (0, _requestmeta.addRequestMeta)(req, 'notFoundRevalidate', (_result_cacheControl1 = result.cacheControl) == null ? void 0 : _result_cacheControl1.revalidate);
+                    res.statusCode = 404;
+                    if (isNextDataRequest) {
+                        res.end('{"notFound":true}');
+                        return;
+                    }
+                    return await render404();
+                }
+                if (result.value.kind === _responsecache.CachedRouteKind.REDIRECT) {
+                    if (isNextDataRequest) {
+                        res.setHeader('content-type', _constants1.JSON_CONTENT_TYPE_HEADER);
+                        res.end(JSON.stringify(result.value.props));
+                        return;
+                    } else {
+                        const handleRedirect = (pageData)=>{
+                            const redirect = {
+                                destination: pageData.pageProps.__N_REDIRECT,
+                                statusCode: pageData.pageProps.__N_REDIRECT_STATUS,
+                                basePath: pageData.pageProps.__N_REDIRECT_BASE_PATH
+                            };
+                            const statusCode = (0, _redirectstatus.getRedirectStatus)(redirect);
+                            const { basePath } = nextConfig;
+                            if (basePath && redirect.basePath !== false && redirect.destination.startsWith('/')) {
+                                redirect.destination = `${basePath}${redirect.destination}`;
+                            }
+                            if (redirect.destination.startsWith('/')) {
+                                redirect.destination = (0, _utils1.normalizeRepeatedSlashes)(redirect.destination);
+                            }
+                            res.statusCode = statusCode;
+                            res.setHeader('Location', redirect.destination);
+                            if (statusCode === _redirectstatuscode.RedirectStatusCode.PermanentRedirect) {
+                                res.setHeader('Refresh', `0;url=${redirect.destination}`);
+                            }
+                            res.end(redirect.destination);
+                        };
+                        await handleRedirect(result.value.props);
+                        return null;
+                    }
+                }
+                if (result.value.kind !== _responsecache.CachedRouteKind.PAGES) {
+                    throw Object.defineProperty(new Error(`Invariant: received non-pages cache entry in pages handler`), "__NEXT_ERROR_CODE", {
+                        value: "E695",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                // In dev, we should not cache pages for any reason.
+                if (routeModule.isDev) {
+                    res.setHeader('Cache-Control', 'no-store, must-revalidate');
+                }
+                // Draft mode should never be cached
+                if (isDraftMode) {
+                    res.setHeader('Cache-Control', 'private, no-cache, no-store, max-age=0, must-revalidate');
+                }
+                // when invoking _error before pages/500 we don't actually
+                // send the _error response
+                if ((0, _requestmeta.getRequestMeta)(req, 'customErrorRender') || isErrorPage && isMinimalMode && res.statusCode === 500) {
+                    return null;
+                }
+                await (0, _sendpayload.sendRenderResult)({
+                    req,
+                    res,
+                    // If we are rendering the error page it's not a data request
+                    // anymore
+                    result: isNextDataRequest && !isErrorPage && !is500Page ? new _renderresult.default(Buffer.from(JSON.stringify(result.value.pageData)), {
+                        contentType: _constants1.JSON_CONTENT_TYPE_HEADER,
+                        metadata: result.value.html.metadata
+                    }) : result.value.html,
+                    generateEtags: nextConfig.generateEtags,
+                    poweredByHeader: nextConfig.poweredByHeader,
+                    cacheControl: routeModule.isDev ? undefined : cacheControl
+                });
+            };
+            // TODO: activeSpan code path is for when wrapped by
+            // next-server can be removed when this is no longer used
+            if (activeSpan) {
+                await handleResponse();
+            } else {
+                await tracer.withPropagatedContext(req.headers, ()=>tracer.trace(_constants.BaseServerSpan.handleRequest, {
+                        spanName: `${method} ${srcPage}`,
+                        kind: _tracer.SpanKind.SERVER,
+                        attributes: {
+                            'http.method': method,
+                            'http.target': req.url
+                        }
+                    }, handleResponse));
+            }
+        } catch (err) {
+            if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
+                const silenceLog = false;
+                await routeModule.onRequestError(req, err, {
+                    routerKind: 'Pages Router',
+                    routePath: srcPage,
+                    routeType: 'render',
+                    revalidateReason: (0, _utils.getRevalidateReason)({
+                        isStaticGeneration: hasStaticProps,
+                        isOnDemandRevalidate
+                    })
+                }, silenceLog, routerServerContext);
+            }
+            // rethrow so that we can handle serving error page
+            throw err;
+        }
+    };
+};
+
+//# sourceMappingURL=pages-handler.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/app-router-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].AppRouterContext;
+
+//# sourceMappingURL=app-router-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/app-router-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/app-router-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].AppRouterContext\n"],"names":["module","exports","require","vendored","AppRouterContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,gBAAgB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.d.ts

@@ -0,0 +1,9 @@
+export * as RouterContext from '../../../../../shared/lib/router-context.shared-runtime';
+export * as LoadableContext from '../../../../../shared/lib/loadable-context.shared-runtime';
+export * as Loadable from '../../../../../shared/lib/loadable.shared-runtime';
+export * as ImageConfigContext from '../../../../../shared/lib/image-config-context.shared-runtime';
+export * as HtmlContext from '../../../../../shared/lib/html-context.shared-runtime';
+export * as HooksClientContext from '../../../../../shared/lib/hooks-client-context.shared-runtime';
+export * as HeadManagerContext from '../../../../../shared/lib/head-manager-context.shared-runtime';
+export * as AppRouterContext from '../../../../../shared/lib/app-router-context.shared-runtime';
+export * as ServerInsertedHtml from '../../../../../shared/lib/server-inserted-html.shared-runtime';

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    AppRouterContext: null,
+    HeadManagerContext: null,
+    HooksClientContext: null,
+    HtmlContext: null,
+    ImageConfigContext: null,
+    Loadable: null,
+    LoadableContext: null,
+    RouterContext: null,
+    ServerInsertedHtml: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AppRouterContext: function() {
+        return _approutercontextsharedruntime;
+    },
+    HeadManagerContext: function() {
+        return _headmanagercontextsharedruntime;
+    },
+    HooksClientContext: function() {
+        return _hooksclientcontextsharedruntime;
+    },
+    HtmlContext: function() {
+        return _htmlcontextsharedruntime;
+    },
+    ImageConfigContext: function() {
+        return _imageconfigcontextsharedruntime;
+    },
+    Loadable: function() {
+        return _loadablesharedruntime;
+    },
+    LoadableContext: function() {
+        return _loadablecontextsharedruntime;
+    },
+    RouterContext: function() {
+        return _routercontextsharedruntime;
+    },
+    ServerInsertedHtml: function() {
+        return _serverinsertedhtmlsharedruntime;
+    }
+});
+const _routercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/router-context.shared-runtime"));
+const _loadablecontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/loadable-context.shared-runtime"));
+const _loadablesharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/loadable.shared-runtime"));
+const _imageconfigcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/image-config-context.shared-runtime"));
+const _htmlcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/html-context.shared-runtime"));
+const _hooksclientcontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/hooks-client-context.shared-runtime"));
+const _headmanagercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/head-manager-context.shared-runtime"));
+const _approutercontextsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/app-router-context.shared-runtime"));
+const _serverinsertedhtmlsharedruntime = /*#__PURE__*/ _interop_require_wildcard(require("../../../../../shared/lib/server-inserted-html.shared-runtime"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+
+//# sourceMappingURL=entrypoints.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/entrypoints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/entrypoints.ts"],"sourcesContent":["export * as RouterContext from '../../../../../shared/lib/router-context.shared-runtime'\nexport * as LoadableContext from '../../../../../shared/lib/loadable-context.shared-runtime'\nexport * as Loadable from '../../../../../shared/lib/loadable.shared-runtime'\nexport * as ImageConfigContext from '../../../../../shared/lib/image-config-context.shared-runtime'\nexport * as HtmlContext from '../../../../../shared/lib/html-context.shared-runtime'\nexport * as HooksClientContext from '../../../../../shared/lib/hooks-client-context.shared-runtime'\nexport * as HeadManagerContext from '../../../../../shared/lib/head-manager-context.shared-runtime'\nexport * as AppRouterContext from '../../../../../shared/lib/app-router-context.shared-runtime'\nexport * as ServerInsertedHtml from '../../../../../shared/lib/server-inserted-html.shared-runtime'\n"],"names":["AppRouterContext","HeadManagerContext","HooksClientContext","HtmlContext","ImageConfigContext","Loadable","LoadableContext","RouterContext","ServerInsertedHtml"],"mappings":";;;;;;;;;;;;;;;;;;;;;;IAOYA,gBAAgB;;;IADhBC,kBAAkB;;;IADlBC,kBAAkB;;;IADlBC,WAAW;;;IADXC,kBAAkB;;;IADlBC,QAAQ;;;IADRC,eAAe;;;IADfC,aAAa;;;IAQbC,kBAAkB;;;;oFARC;sFACE;+EACP;yFACU;kFACP;yFACO;yFACA;uFACF;yFACE","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/head-manager-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].HeadManagerContext;
+
+//# sourceMappingURL=head-manager-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/head-manager-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/head-manager-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].HeadManagerContext\n"],"names":["module","exports","require","vendored","HeadManagerContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/hooks-client-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].HooksClientContext;
+
+//# sourceMappingURL=hooks-client-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/hooks-client-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/hooks-client-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].HooksClientContext\n"],"names":["module","exports","require","vendored","HooksClientContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/html-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].HtmlContext;
+
+//# sourceMappingURL=html-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/html-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/html-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].HtmlContext\n"],"names":["module","exports","require","vendored","HtmlContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,WAAW","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/image-config-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].ImageConfigContext;
+
+//# sourceMappingURL=image-config-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/image-config-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/image-config-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].ImageConfigContext\n"],"names":["module","exports","require","vendored","ImageConfigContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/loadable-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].LoadableContext;
+
+//# sourceMappingURL=loadable-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/loadable-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/loadable-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].LoadableContext\n"],"names":["module","exports","require","vendored","LoadableContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,eAAe","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/loadable.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].Loadable;
+
+//# sourceMappingURL=loadable.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/loadable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/loadable.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].Loadable\n"],"names":["module","exports","require","vendored","Loadable"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,QAAQ","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/router-context.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].RouterContext;
+
+//# sourceMappingURL=router-context.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/router-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/router-context.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].RouterContext\n"],"names":["module","exports","require","vendored","RouterContext"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,aAAa","ignoreList":[0]}

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/server-inserted-html.js

@@ -0,0 +1,4 @@
+"use strict";
+module.exports = require('../../module.compiled').vendored['contexts'].ServerInsertedHtml;
+
+//# sourceMappingURL=server-inserted-html.js.map

apps/public-web/node_modules/next/dist/server/route-modules/pages/vendored/contexts/server-inserted-html.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/route-modules/pages/vendored/contexts/server-inserted-html.ts"],"sourcesContent":["module.exports = (\n  require('../../module.compiled') as typeof import('../../module.compiled')\n).vendored['contexts'].ServerInsertedHtml\n"],"names":["module","exports","require","vendored","ServerInsertedHtml"],"mappings":";AAAAA,OAAOC,OAAO,GAAG,AACfC,QAAQ,yBACRC,QAAQ,CAAC,WAAW,CAACC,kBAAkB","ignoreList":[0]}