vike 0.4.247 → 0.4.249

package/dist/shared-server-client/route/abort.d.ts

@@ -0,0 +1,120 @@
+export { redirect };
+export { render };
+export { RenderErrorPage };
+export { isAbortError };
+export { isAbortPageContext };
+export { logAbort };
+export { getPageContextAddendumAbort };
+export { addNewPageContextAborted };
+export { AbortRender };
+export type { RedirectStatusCode };
+export type { AbortStatusCode };
+export type { ErrorAbort };
+export type { PageContextAborted };
+export type { UrlRedirect };
+export type { PageContextAbort };
+type RedirectStatusCode = number & Parameters<typeof redirect>[1];
+type AbortStatusCode = number & Parameters<InferTwoOverloads<typeof render>[0]>[0];
+type UrlRedirect = {
+    url: string;
+    statusCode: RedirectStatusCode;
+};
+type AbortRedirect = Error;
+type AbortReason = Required<({
+    abortReason?: unknown;
+} & Vike.PageContext)['abortReason']>;
+/**
+ * Abort the rendering of the current page, and redirect the user to another URL instead.
+ *
+ * https://vike.dev/redirect
+ *
+ * @param url The URL to redirect to.
+ * @param statusCode By default the temporary redirection status code (`302`) is sent. For permanent redirections (`301`), use `+redirects` (https://vike.dev/redirects) or set this `statusCode` argument to `301`.
+ */
+declare function redirect(url: string, statusCode?: 301 | 302): AbortRedirect;
+/**
+ * Abort the rendering of the current page, and render the error page instead.
+ *
+ * https://vike.dev/render
+ *
+ *
+ * **Recommended** status codes:
+ *   `401` — Unauthorized (user isn't logged in)
+ *   `403` — Forbidden (user is logged in but isn't allowed)
+ *   `404` — Not Found
+ *   `410` — Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
+ *   `429` — Too Many Requests (rate limiting)
+ *   `500` — Internal Server Error (your client or server has a bug)
+ *   `503` — Service Unavailable (server is overloaded, or a third-party API isn't responding)
+ *
+ * **Not recommended** status codes:
+ *   `400` — See https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445
+ *   Other status codes — See https://github.com/vikejs/vike/issues/1008
+ *
+ * @param abortStatusCode - One of the recommended status codes listed above.
+ *
+ * @param abortReason - Sets `pageContext.abortReason` which is usually used by the error page to show a message to the user, see https://vike.dev/error-page
+ */
+declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503, abortReason?: AbortReason): Error;
+/**
+ * Abort the rendering of the current page, and render another page instead.
+ *
+ * https://vike.dev/render
+ *
+ * @param url The URL to render.
+ * @param abortReason Sets `pageContext.abortReason` which is used by the error page to show a message to the user, see https://vike.dev/error-page
+ */
+declare function render(url: `/${string}`, abortReason?: AbortReason): Error;
+type AbortCall = `redirect(${string})` | `render(${string})` | `RenderErrorPage()`;
+type AbortCaller = `throw redirect()` | `throw render()` | `throw RenderErrorPage()`;
+type PageContextAbort = {
+    _abortCall: AbortCall;
+    _abortCaller: AbortCaller;
+} & (({
+    _abortCall: `redirect(${string})`;
+    _abortCaller: 'throw redirect()';
+    _urlRedirect: UrlRedirect;
+} & Omit<AbortUndefined, '_urlRedirect'>) | ({
+    _abortCall: `render(${string})` | `RenderErrorPage()`;
+    _abortCaller: 'throw render()' | 'throw RenderErrorPage()';
+    abortReason: undefined | unknown;
+    _urlRewrite: string;
+} & Omit<AbortUndefined, '_urlRewrite'>) | ({
+    _abortCall: `render(${string})` | `RenderErrorPage()`;
+    _abortCaller: 'throw render()' | 'throw RenderErrorPage()';
+    abortReason: undefined | unknown;
+    abortStatusCode: AbortStatusCode;
+} & Omit<AbortUndefined, 'abortStatusCode'>));
+type AbortUndefined = {
+    _urlRedirect?: undefined;
+    _urlRewrite?: undefined;
+    abortStatusCode?: undefined;
+};
+declare function AbortRender(pageContextAbort: PageContextAbort): Error;
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+declare function RenderErrorPage({ pageContext }?: {
+    pageContext?: Record<string, unknown>;
+}): Error;
+type ErrorAbort = {
+    _pageContextAbort: PageContextAbort;
+};
+declare function isAbortError(thing: unknown): thing is ErrorAbort;
+declare function isAbortPageContext(pageContext: Record<string, unknown>): pageContext is PageContextAbort;
+declare function logAbort(err: ErrorAbort, isProduction: boolean, pageContext: {
+    urlOriginal: string;
+    _urlRewrite?: string;
+}): void;
+type PageContextMin = {
+    urlOriginal: string;
+};
+type PageContextAborted = {
+    _pageContextAbort: PageContextAbort;
+} & PageContextMin;
+declare function getPageContextAddendumAbort(pageContextsAborted: PageContextAborted[]): PageContextAbort | null;
+declare function addNewPageContextAborted(pageContextsAborted: PageContextAborted[], pageContext: PageContextMin, pageContextAbort: PageContextAbort): void;
+type InferTwoOverloads<F extends Function> = F extends {
+    (...a1: infer A1): infer R1;
+    (...a0: infer A0): infer R0;
+} ? [(...a1: A1) => R1, (...a0: A0) => R0] : never;

package/dist/shared-server-client/route/abort.js

@@ -0,0 +1,207 @@
+export { redirect };
+export { render };
+export { RenderErrorPage };
+export { isAbortError };
+export { isAbortPageContext };
+export { logAbort };
+export { getPageContextAddendumAbort };
+export { addNewPageContextAborted };
+export { AbortRender };
+import { isUserHookError } from '../hooks/execHook.js';
+import { assert, assertInfo, assertUsage, assertUsageUrlPathAbsolute, assertUsageUrlRedirectTarget, assertWarning, checkType, hasProp, isBrowser, joinEnglish, objectAssign, truncateString, unique, } from './utils.js';
+import pc from '@brillout/picocolors';
+/**
+ * Abort the rendering of the current page, and redirect the user to another URL instead.
+ *
+ * https://vike.dev/redirect
+ *
+ * @param url The URL to redirect to.
+ * @param statusCode By default the temporary redirection status code (`302`) is sent. For permanent redirections (`301`), use `+redirects` (https://vike.dev/redirects) or set this `statusCode` argument to `301`.
+ */
+function redirect(url, statusCode) {
+    const abortCaller = 'throw redirect()';
+    assertUsageUrlRedirectTarget(url, getErrPrefix(abortCaller));
+    const args = [JSON.stringify(url)];
+    if (!statusCode) {
+        statusCode = 302;
+    }
+    else {
+        if (
+        // Tree-shaking to save client-side KBs
+        !globalThis.__VIKE__IS_CLIENT ||
+            globalThis.__VIKE__IS_DEV ||
+            globalThis.__VIKE__IS_DEBUG) {
+            assertStatusCode(statusCode, [301, 302], 'redirect');
+        }
+        args.push(String(statusCode));
+    }
+    const pageContextAbort = {};
+    objectAssign(pageContextAbort, {
+        _abortCaller: abortCaller,
+        _abortCall: `redirect(${args.join(', ')})`,
+        _urlRedirect: {
+            url,
+            statusCode,
+        },
+    });
+    return AbortRender(pageContextAbort);
+}
+function render(urlOrStatusCode, abortReason) {
+    const args = [typeof urlOrStatusCode === 'number' ? String(urlOrStatusCode) : JSON.stringify(urlOrStatusCode)];
+    if (abortReason !== undefined)
+        args.push(truncateString(JSON.stringify(abortReason), 30));
+    const abortCaller = 'throw render()';
+    const abortCall = `render(${args.join(', ')})`;
+    return render_(urlOrStatusCode, abortReason, abortCall, abortCaller);
+}
+function render_(urlOrStatusCode, abortReason, abortCall, abortCaller, pageContextAddendum) {
+    const pageContextAbort = {
+        abortReason,
+        _abortCaller: abortCaller,
+        _abortCall: abortCall,
+    };
+    if (pageContextAddendum) {
+        assert(pageContextAddendum._isLegacyRenderErrorPage === true);
+        objectAssign(pageContextAbort, pageContextAddendum);
+    }
+    if (typeof urlOrStatusCode === 'string') {
+        const url = urlOrStatusCode;
+        assertUsageUrlPathAbsolute(url, getErrPrefix(abortCaller));
+        objectAssign(pageContextAbort, {
+            _urlRewrite: url,
+        });
+        return AbortRender(pageContextAbort);
+    }
+    else {
+        if (
+        // Tree-shaking to save client-side KBs
+        !globalThis.__VIKE__IS_CLIENT ||
+            globalThis.__VIKE__IS_DEV ||
+            globalThis.__VIKE__IS_DEBUG) {
+            assertStatusCode(urlOrStatusCode, [401, 403, 404, 410, 429, 500, 503], 'render');
+        }
+        const abortStatusCode = urlOrStatusCode;
+        objectAssign(pageContextAbort, {
+            abortStatusCode,
+            is404: abortStatusCode === 404,
+        });
+        return AbortRender(pageContextAbort);
+    }
+}
+function AbortRender(pageContextAbort) {
+    const err = new Error('AbortRender');
+    objectAssign(err, { _pageContextAbort: pageContextAbort, [stamp]: true });
+    checkType(err);
+    return err;
+}
+// TO-DO/next-major-release: remove
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+function RenderErrorPage({ pageContext = {} } = {}) {
+    assertWarning(false, `${pc.cyan('throw RenderErrorPage()')} is deprecated and will be removed in the next major release. Use ${pc.cyan('throw render()')} or ${pc.cyan('throw redirect()')} instead, see https://vike.dev/render`, { onlyOnce: false });
+    let abortStatusCode = 404;
+    let abortReason = 'Page Not Found';
+    if (pageContext.is404 === false || pageContext.pageProps?.is404 === false) {
+        abortStatusCode = 500;
+        abortReason = 'Something went wrong';
+    }
+    objectAssign(pageContext, { _isLegacyRenderErrorPage: true });
+    return render_(abortStatusCode, abortReason, 'RenderErrorPage()', 'throw RenderErrorPage()', pageContext);
+}
+const stamp = '_isAbortError';
+function isAbortError(thing) {
+    return typeof thing === 'object' && thing !== null && stamp in thing;
+}
+function isAbortPageContext(pageContext) {
+    if (!(pageContext._urlRewrite || pageContext._urlRedirect || pageContext.abortStatusCode)) {
+        return false;
+    }
+    assert(hasProp(pageContext, '_abortCall', 'string'));
+    /* Isn't needed and is missing on the client-side
+    assert(hasProp(pageContext, '_abortCaller', 'string'))
+    */
+    checkType(pageContext);
+    return true;
+}
+function logAbort(err, isProduction, pageContext) {
+    if (isProduction)
+        return;
+    const urlCurrent = pageContext._urlRewrite ?? pageContext.urlOriginal;
+    assert(urlCurrent);
+    const abortCall = err._pageContextAbort._abortCall;
+    assert(abortCall);
+    const hookLoc = isUserHookError(err);
+    let thrownBy = '';
+    if (hookLoc) {
+        thrownBy = ` by ${pc.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
+    }
+    else {
+        // hookLoc is missing when serializing abort errors from server to client
+    }
+    assertInfo(false, `${pc.cyan(abortCall)} thrown${thrownBy} while rendering ${pc.cyan(urlCurrent)}`, {
+        onlyOnce: false,
+    });
+}
+function assertStatusCode(statusCode, expected, caller) {
+    assert(!globalThis.__VIKE__IS_CLIENT || globalThis.__VIKE__IS_DEV || globalThis.__VIKE__IS_DEBUG); // assert tree-shaking
+    // double check vike:pluginReplaceConstantsGlobalThis
+    if (globalThis.__VIKE__IS_CLIENT) {
+        assert(isBrowser());
+        assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');
+        assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
+        assert(import.meta.env.SSR === false);
+        assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
+    }
+    else {
+        assert(!isBrowser());
+        if (import.meta.env) {
+            assert(typeof globalThis.__VIKE__IS_DEV === 'boolean');
+            assert(typeof globalThis.__VIKE__IS_CLIENT === 'boolean');
+            assert(import.meta.env.SSR === true);
+            assert(import.meta.env.DEV === globalThis.__VIKE__IS_DEV);
+        }
+        else {
+            // import.meta.env isn't defined when 'vike' is ssr.external
+        }
+    }
+    const expectedEnglish = joinEnglish(expected.map((s) => pc.bold(String(s))), 'or');
+    const statusCodeWithColor = pc.bold(String(statusCode));
+    if (statusCode === 400) {
+        assert(!expected.includes(statusCode));
+        assertWarning(false, `We recommend against using the status code ${statusCodeWithColor} passed to ${caller}() — we recommend using ${pc.bold('404')} instead, see https://github.com/vikejs/vike/issues/1008#issuecomment-3270894445`, { onlyOnce: true, showStackTrace: true });
+    }
+    else {
+        assertWarning(expected.includes(statusCode), `Unexpected status code ${statusCodeWithColor} passed to ${caller}() — we recommend using ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCodeWithColor} should be added.)`, { onlyOnce: true, showStackTrace: true });
+    }
+}
+function getPageContextAddendumAbort(pageContextsAborted) {
+    const pageContextAbortedLast = pageContextsAborted.at(-1);
+    if (!pageContextAbortedLast)
+        return null;
+    const pageContextAbort = pageContextAbortedLast._pageContextAbort;
+    assert(pageContextAbort);
+    // Sets pageContext._urlRewrite from pageContextAbort._urlRewrite
+    return pageContextAbort;
+}
+function addNewPageContextAborted(pageContextsAborted, pageContext, pageContextAbort) {
+    objectAssign(pageContext, { _pageContextAbort: pageContextAbort });
+    pageContextsAborted.push(pageContext);
+    assertNoInfiniteAbortLoop(pageContextsAborted);
+}
+// There doesn't seem to be a way to count the number of HTTP redirects (Vike doesn't have access to the HTTP request headers/cookies)
+// https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
+function assertNoInfiniteAbortLoop(pageContextsAborted) {
+    if (pageContextsAborted.length < 10)
+        return;
+    const loop = pageContextsAborted.map((pageContext) => {
+        return pageContext._pageContextAbort._abortCall;
+    });
+    // Unique array => no redundant call => no infinite loop
+    if (unique(loop).length === loop.length)
+        return;
+    assertUsage(false, `Infinite loop: ${loop.join(' => ')}`);
+}
+function getErrPrefix(abortCaller) {
+    return `URL passed to ${pc.code(abortCaller)}`;
+}

package/dist/shared-server-node/api-context.d.ts

@@ -0,0 +1,13 @@
+export { isVikeCliOrApi };
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+import type { ApiOptions, ApiOperation } from '../node/api/types.js';
+type VikeApiOperation = {
+    operation: ApiOperation;
+    options: ApiOptions;
+};
+declare function getVikeApiOperation(): VikeApiOperation | null;
+declare function isVikeCliOrApi(): boolean;
+declare function setContextVikeApiOperation(operation: ApiOperation, options: ApiOptions): void;
+declare function clearContextVikeApiOperation(): void;

package/dist/shared-server-node/api-context.js

@@ -0,0 +1,21 @@
+export { isVikeCliOrApi };
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+// We don't import ./utils.js because this file is imported by server/
+import { assert, getGlobalObject } from '../server/utils.js';
+const globalObject = getGlobalObject('api/context.ts', {});
+function getVikeApiOperation() {
+    return globalObject.vikeApiOperation ?? null;
+}
+function isVikeCliOrApi() {
+    // The CLI uses the API
+    return !!globalObject.vikeApiOperation;
+}
+function setContextVikeApiOperation(operation, options) {
+    assert(!globalObject.vikeApiOperation);
+    globalObject.vikeApiOperation = { operation, options };
+}
+function clearContextVikeApiOperation() {
+    globalObject.vikeApiOperation = undefined;
+}

package/dist/shared-server-node/assertV1Design.d.ts

@@ -0,0 +1,4 @@
+export { assertV1Design };
+import { PageFile } from '../shared-server-client/getPageFiles.js';
+import type { PageConfigBuildTime } from '../types/PageConfig.js';
+declare function assertV1Design(pageConfigs: PageConfigBuildTime[] | boolean, pageFilesAll: PageFile[] | boolean): void;

package/dist/shared-server-node/getFileSuffixes.d.ts

@@ -0,0 +1,6 @@
+export { getFileSuffixes };
+export { suffixesAssertFileEnv };
+declare const suffixesAssertFileEnv: readonly ["server", "client", "ssr"];
+declare const suffixes: readonly ["server", "client", "ssr", "shared", "clear", "default"];
+type Suffix = (typeof suffixes)[number];
+declare function getFileSuffixes(fileName: string): Suffix[];

package/dist/shared-server-node/getFileSuffixes.js

@@ -0,0 +1,22 @@
+export { getFileSuffixes };
+export { suffixesAssertFileEnv };
+const suffixesAssertFileEnv = [
+    // .server.js
+    'server',
+    // .client.js
+    'client',
+    // .ssr.js
+    'ssr',
+];
+const suffixes = [
+    ...suffixesAssertFileEnv,
+    // .shared.js
+    'shared',
+    // .clear.js
+    'clear',
+    // .default.js
+    'default',
+];
+function getFileSuffixes(fileName) {
+    return suffixes.filter((suffix) => fileName.includes(`.${suffix}.`));
+}

package/dist/shared-server-node/getVikeConfigError.d.ts

@@ -0,0 +1,22 @@
+export { getVikeConfigError };
+export { getVikeConfigErrorBuild };
+export { setVikeConfigError };
+export { debugFileChange };
+declare const debugFileChange: ((...msgs: unknown[]) => void) & {
+    options: (optionsLocal: {
+        serialization?: {
+            emptyArray?: string;
+        };
+    }) => (...msgs: unknown[]) => void;
+    isActivated: boolean;
+};
+type VikeConfigHasError = false | {
+    err: unknown;
+};
+declare function setVikeConfigError(val: {
+    errorRuntime: VikeConfigHasError;
+} | {
+    errorBuild: VikeConfigHasError;
+}): void;
+declare function getVikeConfigError(): VikeConfigHasError;
+declare function getVikeConfigErrorBuild(): VikeConfigHasError;

package/dist/shared-server-node/getVikeConfigError.js

@@ -0,0 +1,23 @@
+export { getVikeConfigError };
+export { getVikeConfigErrorBuild };
+export { setVikeConfigError };
+export { debugFileChange };
+import { getGlobalObject, createDebug } from './utils.js';
+const globalObject = getGlobalObject('server/shared/getVikeConfigError.ts', {
+    errorRuntime: false,
+    errorBuild: false,
+});
+const debugFileChange = createDebug('vike:file-change');
+function setVikeConfigError(val) {
+    debugFileChange('setVikeConfigError()', val);
+    if ('errorRuntime' in val)
+        globalObject.errorRuntime = val.errorRuntime;
+    if ('errorBuild' in val)
+        globalObject.errorBuild = val.errorBuild;
+}
+function getVikeConfigError() {
+    return globalObject.errorBuild || globalObject.errorRuntime;
+}
+function getVikeConfigErrorBuild() {
+    return globalObject.errorBuild;
+}

package/dist/shared-server-node/utils.d.ts

@@ -0,0 +1 @@
+export * from '../server/utils.js';

package/dist/shared-server-node/utils.js

@@ -0,0 +1,4 @@
+// We can load all server/utils.ts since shared-server-node/ imports from server/runime/ anyways.
+// And since /server/runime/ imports from shared-server-node/ both list of utils can be kept equivalent => this file can stay as-is.
+// While node/vite/ imports from shared-server-node/ the inverse isn't true: shared-server-node/ doesn't import from node/vite/ => node/vite/utils.ts can be (and actually is) a superset of shared-server-node/utils.js
+export * from '../server/utils.js';

package/dist/shared-server-node/virtualFileId.js

@@ -0,0 +1,108 @@
+export { parseVirtualFileId };
+export { generateVirtualFileId };
+export { virtualFileIdGlobalEntryServer };
+export { virtualFileIdGlobalEntryClientSR };
+export { virtualFileIdGlobalEntryClientCR };
+import { extractAssetsRemoveQuery } from './extractAssetsQuery.js';
+import { assert, assertIsNotBrowser, removeVirtualFileIdPrefix } from './utils.js';
+assertIsNotBrowser();
+// Global entries
+const virtualFileIdGlobalEntryServer = 
+//
+'virtual:vike:global-entry:server';
+const virtualFileIdGlobalEntryClientSR = 
+//
+'virtual:vike:global-entry:client:server-routing';
+const virtualFileIdGlobalEntryClientCR = 
+//
+'virtual:vike:global-entry:client:client-routing';
+// Page entries
+const virtualFileIdPageEntryClient = 
+//
+'virtual:vike:page-entry:client:'; // ${pageId}
+const virtualFileIdPageEntryServer = 
+//
+'virtual:vike:page-entry:server:'; //  ${pageId}
+// Virtual ID prefixes
+const virtualFileIdPageEntryPrefix = 
+//
+'virtual:vike:page-entry:';
+const virtualFileIdGlobalEntryPrefix = 
+//
+'virtual:vike:global-entry:';
+function parseVirtualFileId(id) {
+    id = removeVirtualFileIdPrefix(id);
+    if (!id.startsWith(virtualFileIdGlobalEntryPrefix) && !id.startsWith(virtualFileIdPageEntryPrefix))
+        return false;
+    // Global entry
+    if (id.includes(virtualFileIdGlobalEntryPrefix)) {
+        const isForClientSide = id !== virtualFileIdGlobalEntryServer;
+        const isClientRouting = id === virtualFileIdGlobalEntryClientCR;
+        return {
+            type: 'global-entry',
+            isForClientSide,
+            isClientRouting,
+        };
+    }
+    // Page entry
+    if (id.includes(virtualFileIdPageEntryPrefix)) {
+        const idOriginal = id;
+        id = extractAssetsRemoveQuery(id);
+        const isExtractAssets = idOriginal !== id;
+        if (id.startsWith(virtualFileIdPageEntryClient)) {
+            assert(isExtractAssets === false);
+            const pageIdSerialized = id.slice(virtualFileIdPageEntryClient.length);
+            const pageId = deserializePageId(pageIdSerialized);
+            return {
+                type: 'page-entry',
+                pageId,
+                isForClientSide: true,
+                isExtractAssets,
+            };
+        }
+        if (id.startsWith(virtualFileIdPageEntryServer)) {
+            const pageIdSerialized = id.slice(virtualFileIdPageEntryServer.length);
+            const pageId = deserializePageId(pageIdSerialized);
+            return {
+                type: 'page-entry',
+                pageId,
+                isForClientSide: false,
+                isExtractAssets,
+            };
+        }
+        assert(false);
+    }
+    return false;
+}
+function generateVirtualFileId(args) {
+    if (args.type === 'global-entry') {
+        const { isForClientSide, isClientRouting } = args;
+        if (!isForClientSide) {
+            return virtualFileIdGlobalEntryServer;
+        }
+        else if (isClientRouting) {
+            return virtualFileIdGlobalEntryClientCR;
+        }
+        else {
+            return virtualFileIdGlobalEntryClientSR;
+        }
+    }
+    if (args.type === 'page-entry') {
+        const { pageId, isForClientSide } = args;
+        const pageIdSerialized = serializePageId(pageId);
+        const id = `${isForClientSide ? virtualFileIdPageEntryClient : virtualFileIdPageEntryServer}${pageIdSerialized}`;
+        return id;
+    }
+    assert(false);
+}
+// Workaround:
+// - We replace virtual:vike:page-entry:client:/ with virtual:vike:page-entry:client:ROOT
+// - In order to avoid Vite to replace `virtual:vike:page-entry:client:/` with `virtual:vike:page-entry:client:`
+// - I guess Vite/Rollup mistakenly treat the virtual ID as a path and tries to normalize id
+const ROOT = 'ROOT';
+function serializePageId(pageId) {
+    return pageId === '/' ? ROOT : pageId;
+}
+function deserializePageId(pageId) {
+    return pageId === ROOT ? '/' : pageId;
+}