vike 0.4.146 → 0.4.147-commit-f9a91f3

package/dist/cjs/node/runtime/renderPage/getHttpResponseBody.js

@@ -11,7 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const streamDocs = 'See https://vike.dev/stream for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
-        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} or ${picocolors_1.default.cyan('pageContext.httpResponse.getBody()')} instead`));
+        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} instead`));
     }
     const body = htmlRender;
     return body;

package/dist/cjs/node/runtime/renderPage.js

@@ -39,17 +39,17 @@ async function renderPage(pageContextInit) {
     (0, assertArguments_js_1.assertArguments)(...arguments);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string'));
     (0, utils_js_1.assertEnv)();
-    if (skipRequest(pageContextInit.urlOriginal)) {
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        (0, utils_js_1.checkType)(pageContextHttpReponseNull);
-        return pageContextHttpReponseNull;
+    if (isIgnoredUrl(pageContextInit.urlOriginal)) {
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        (0, utils_js_1.checkType)(pageContextHttpResponseNull);
+        return pageContextHttpResponseNull;
     }
     const httpRequestId = getRequestId();
-    const urlToShowToUser = pageContextInit.urlOriginal;
-    logHttpRequest(urlToShowToUser, httpRequestId);
+    const { urlOriginal } = pageContextInit;
+    logHttpRequest(urlOriginal, httpRequestId);
     globalObject.pendingRequestsCount++;
     const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
-    logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn);
+    logHttpResponse(urlOriginal, httpRequestId, pageContextReturn);
     globalObject.pendingRequestsCount--;
     onRequestDone();
     (0, utils_js_1.checkType)(pageContextReturn);
@@ -60,8 +60,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     // Invalid config
     const handleInvalidConfig = () => {
         (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.red("Couldn't load configuration: see error above.")), httpRequestId, 'error');
-        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
     };
     if (isConfigInvalid_js_1.isConfigInvalid) {
         return handleInvalidConfig();
@@ -77,8 +77,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
         (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
         (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
-        const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
-        return pageContextHttpReponseNull;
+        const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
+        return pageContextHttpResponseNull;
     }
     if (isConfigInvalid_js_1.isConfigInvalid) {
         return handleInvalidConfig();
@@ -86,15 +86,23 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
     else {
         // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
+    // Check Base URL
+    {
+        const pageContextHttpResponse = checkBaseUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
+    }
+    // Normalize URL
     {
-        const pageContextHttpReponse = normalizeUrl(pageContextInit, httpRequestId);
-        if (pageContextHttpReponse)
-            return pageContextHttpReponse;
+        const pageContextHttpResponse = normalizeUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
     }
+    // Permanent redirects (HTTP status code `301`)
     {
-        const pageContextHttpReponse = getPermanentRedirect(pageContextInit, httpRequestId);
-        if (pageContextHttpReponse)
-            return pageContextHttpReponse;
+        const pageContextHttpResponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        if (pageContextHttpResponse)
+            return pageContextHttpResponse;
     }
     return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, []);
 }
@@ -177,8 +185,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
                     (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-                    return pageContextHttpReponseNull;
+                    const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+                    return pageContextHttpResponseNull;
                 }
                 // `throw redirect()` / `throw render(url)`
                 return handled.pageContextReturn;
@@ -186,18 +194,28 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
                 (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
             }
-            const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
-            return pageContextHttpReponseNull;
+            const pageContextHttpResponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+            return pageContextHttpResponseNull;
         }
         return pageContextErrorPage;
     }
 }
-function logHttpRequest(urlToShowToUser, httpRequestId) {
+function logHttpRequest(urlOriginal, httpRequestId) {
     const clearErrors = globalObject.pendingRequestsCount === 0;
-    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP request: ${picocolors_1.default.bold(urlToShowToUser)}`, httpRequestId, 'info', clearErrors);
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info', clearErrors);
 }
-function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
+function getRequestInfoMessage(urlOriginal) {
+    return `HTTP request: ${picocolors_1.default.bold(urlOriginal)}`;
+}
+function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
     const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
+    {
+        // If URL doesn't include Base URL
+        const { errorWhileRendering } = pageContextReturn;
+        const isSkipped = statusCode === null && (errorWhileRendering === null || errorWhileRendering === undefined);
+        if (isSkipped)
+            return;
+    }
     const isSuccess = statusCode !== null && statusCode >= 200 && statusCode <= 399;
     const isNominal = isSuccess || statusCode === 404;
     const color = (s) => picocolors_1.default.bold(isSuccess ? picocolors_1.default.green(String(s)) : picocolors_1.default.red(String(s)));
@@ -211,39 +229,30 @@ function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
             .find((header) => header[0] === 'Location');
         (0, utils_js_1.assert)(headerRedirect);
         const urlRedirect = headerRedirect[1];
-        urlToShowToUser = urlRedirect;
+        urlOriginal = urlRedirect;
     }
-    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP ${type} ${picocolors_1.default.bold(urlToShowToUser)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP ${type} ${picocolors_1.default.bold(urlOriginal)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
 }
 function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: err
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpReponseNull = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, {
+    const pageContextHttpResponseNull = {};
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: null
     });
-    return pageContextHttpReponseNull;
+    return pageContextHttpResponseNull;
 }
 async function renderPageNominal(pageContext) {
     (0, utils_js_1.objectAssign)(pageContext, { errorWhileRendering: null });
-    // Check Base URL
-    {
-        const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(pageContext.urlOriginal);
-        const hasBaseServer = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, pageContext._baseServer).hasBaseServer || !!pageContext._urlRewrite;
-        if (!hasBaseServer) {
-            (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
-            return pageContext;
-        }
-    }
     // Route
     {
         const pageContextFromRoute = await (0, index_js_1.route)(pageContext);
@@ -309,7 +318,7 @@ function getRequestId() {
     (0, utils_js_1.assert)(httpRequestId >= 1);
     return httpRequestId;
 }
-function skipRequest(urlOriginal) {
+function isIgnoredUrl(urlOriginal) {
     const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
     (0, utils_js_1.assertWarning)(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
     return (urlOriginal.endsWith('/__vite_ping') ||
@@ -318,11 +327,11 @@ function skipRequest(urlOriginal) {
         isViteClientRequest);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
-    const { trailingSlash, disableUrlNormalization } = (0, globalContext_js_1.getGlobalContext)();
+    const { trailingSlash, disableUrlNormalization, baseServer } = (0, globalContext_js_1.getGlobalContext)();
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContextInit;
-    const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash);
+    const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash, baseServer);
     if (!urlNormalized)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
@@ -333,10 +342,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = (0, globalContext_js_1.getGlobalContext)();
     const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = (0, resolveRedirects_js_1.resolveRedirects)(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -346,13 +353,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = (0, utils_js_1.addUrlOrigin)(urlTarget, origin);
-    (0, utils_js_1.assert)(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
     (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -396,10 +402,28 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = (0, utils_js_1.createUrlFromComponents)(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
     (0, utils_js_1.assert)(pageContextAbort.abortStatusCode);
     return { pageContextAbort };
 }
+function checkBaseUrl(pageContextInit, httpRequestId) {
+    const { baseServer } = (0, globalContext_js_1.getGlobalContext)();
+    const { urlOriginal } = pageContextInit;
+    const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
+    const { hasBaseServer } = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, baseServer);
+    if (!hasBaseServer) {
+        (0, loggerRuntime_js_1.logRuntimeInfo)?.(`${getRequestInfoMessage(urlOriginal)} skipped because URL ${picocolors_1.default.bold(urlOriginal)} doesn't start with Base URL ${picocolors_1.default.bold(baseServer)} (https://vike.dev/base-url)`, httpRequestId, 'info');
+        const pageContextHttpResponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpResponseNull;
+    }
+    return null;
+}

package/dist/cjs/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -1,4 +1,5 @@
 "use strict";
+// TODO/v1-release: remove
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVikeClientEntry = exports.determineClientEntry = void 0;
 function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {

package/dist/cjs/shared/page-configs/loadConfigValues.js

@@ -3,15 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfigValues = void 0;
 const utils_js_1 = require("../utils.js");
 const parseConfigValuesImported_js_1 = require("./serialize/parseConfigValuesImported.js");
+const parseConfigValuesSerialized_js_1 = require("./serialize/parseConfigValuesSerialized.js");
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
         !isDev) {
         return pageConfig;
     }
-    const configValuesImported = await pageConfig.loadConfigValuesAll();
-    const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
-    Object.assign(pageConfig.configValues, configValuesAddendum);
+    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    {
+        const { configValuesImported } = configValuesLoaded;
+        const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
+        Object.assign(pageConfig.configValues, configValuesAddendum);
+    }
+    {
+        const { configValuesSerialized } = configValuesLoaded;
+        const configValuesAddendum = (0, parseConfigValuesSerialized_js_1.parseConfigValuesSerialized)(configValuesSerialized);
+        Object.assign(pageConfig.configValues, configValuesAddendum);
+    }
     (0, utils_js_1.objectAssign)(pageConfig, { isAllLoaded: true });
     return pageConfig;
 }

package/dist/cjs/shared/page-configs/serialize/parseConfigValuesSerialized.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfigValuesSerialized = void 0;
+const utils_js_1 = require("../../utils.js");
+const parse_1 = require("@brillout/json-serializer/parse");
+function parseConfigValuesSerialized(configValuesSerialized) {
+    const configValues = {};
+    Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+        const { valueSerialized, definedAt } = configValueSeriliazed;
+        (0, utils_js_1.assert)(valueSerialized);
+        (0, utils_js_1.assert)(!configValues[configName]);
+        configValues[configName] = {
+            value: (0, parse_1.parse)(valueSerialized),
+            definedAt
+        };
+    });
+    return configValues;
+}
+exports.parseConfigValuesSerialized = parseConfigValuesSerialized;

package/dist/cjs/shared/page-configs/serialize/parsePageConfigs.js

@@ -1,26 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePageConfigs = void 0;
-const parse_1 = require("@brillout/json-serializer/parse");
 const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
 const utils_js_1 = require("../../utils.js");
 const helpers_js_1 = require("../helpers.js");
+const parseConfigValuesSerialized_js_1 = require("./parseConfigValuesSerialized.js");
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
         {
             const { configValuesSerialized } = pageConfigSerialized;
-            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
-                {
-                    const { valueSerialized, definedAt } = configValueSeriliazed;
-                    (0, utils_js_1.assert)(valueSerialized);
-                    (0, utils_js_1.assert)(!configValues[configName]);
-                    configValues[configName] = {
-                        value: (0, parse_1.parse)(valueSerialized),
-                        definedAt
-                    };
-                }
-            });
+            const configValuesAddendum = (0, parseConfigValuesSerialized_js_1.parseConfigValuesSerialized)(configValuesSerialized);
+            Object.assign(configValues, configValuesAddendum);
         }
         {
             const { configValuesImported } = pageConfigSerialized;

package/dist/cjs/shared/route/resolveRedirects.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRouteStringRedirect = exports.resolveRedirects = void 0;
 const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const parseUrl_extras_js_1 = require("../../utils/parseUrl-extras.js");
 const utils_js_1 = require("../utils.js");
 const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -23,9 +24,9 @@ exports.resolveRedirects = resolveRedirects;
 function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     (0, resolveRouteString_js_1.assertRouteString)(urlSource, `${configSrc} Invalid`);
     (0, utils_js_1.assertUsage)(urlTarget.startsWith('/') ||
-        urlTarget.startsWith('http://') ||
-        urlTarget.startsWith('https://') ||
-        urlTarget === '*', `${configSrc} Invalid redirection target URL ${picocolors_1.default.cyan(urlTarget)}: the target URL should start with ${picocolors_1.default.cyan('/')}, ${picocolors_1.default.cyan('http://')}, ${picocolors_1.default.cyan('https://')}, or be ${picocolors_1.default.cyan('*')}`);
+        // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+        (0, parseUrl_extras_js_1.isUriWithProtocol)(urlTarget) ||
+        urlTarget === '*', `${configSrc} Invalid redirection target URL ${picocolors_1.default.cyan(urlTarget)}: the target URL should start with ${picocolors_1.default.cyan('/')}, a valid protocol (${picocolors_1.default.cyan('https:')}, ${picocolors_1.default.cyan('http:')}, ${picocolors_1.default.cyan('ipfs:')}, ${picocolors_1.default.cyan('magnet:')}, ...), or be ${picocolors_1.default.cyan('*')}`);
     assertParams(urlSource, urlTarget);
     const match = (0, resolveRouteString_js_1.resolveRouteString)(urlSource, urlPathname);
     if (!match)
@@ -37,10 +38,12 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
         }
         urlResolved = urlResolved.replaceAll(key, val);
     });
-    (0, utils_js_1.assert)(!urlResolved.includes('@'));
+    if (!urlResolved.startsWith('mailto:')) {
+        (0, utils_js_1.assertUsage)(!urlResolved.includes('@'), 'URL should not contain "@" unless it is a mailto link.');
+    }
     if (urlResolved === urlPathname)
         return null;
-    (0, utils_js_1.assert)(urlTarget.startsWith('/') || urlTarget.startsWith('http'));
+    (0, utils_js_1.assert)(urlResolved.startsWith('/') || (0, parseUrl_extras_js_1.isUriWithProtocol)(urlResolved));
     return urlResolved;
 }
 exports.resolveRouteStringRedirect = resolveRouteStringRedirect;

package/dist/cjs/utils/assertKeys.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertKeys = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assert_js_1 = require("./assert.js");
+const joinEnglish_js_1 = require("./joinEnglish.js");
+function assertKeys(obj, keysExpected, errPrefix) {
+    const keysUnknown = [];
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (!keysExpected.includes(key)) {
+            keysUnknown.push(key);
+        }
+    }
+    if (keysUnknown.length !== 0) {
+        (0, assert_js_1.assertUsage)(false, [
+            errPrefix,
+            `unknown key${keysUnknown.length === 1 ? '' : 's'}`,
+            (0, joinEnglish_js_1.joinEnglish)(keysUnknown, 'and', picocolors_1.default.cyan) + '.',
+            'Only following keys are allowed:',
+            (0, joinEnglish_js_1.joinEnglish)(keysExpected, 'and', picocolors_1.default.cyan) + '.'
+        ].join(' '));
+    }
+}
+exports.assertKeys = assertKeys;

package/dist/cjs/utils/joinEnglish.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.joinEnglish = void 0;
 const assert_js_1 = require("./assert.js");
 // https://stackoverflow.com/questions/53879088/join-an-array-by-commas-and-and/53879103#53879103
-function joinEnglish(arr, conjunction) {
+function joinEnglish(arr, conjunction, colorizer = (s) => s) {
     (0, assert_js_1.assert)(arr.length > 0);
     if (arr.length === 1)
-        return arr[0];
+        return colorizer(arr[0]);
     const firsts = arr.slice(0, arr.length - 1);
     const last = arr[arr.length - 1];
-    return firsts.join(', ') + ` ${conjunction} ` + last;
+    return firsts.map(colorizer).join(', ') + ` ${conjunction} ` + colorizer(last);
 }
 exports.joinEnglish = joinEnglish;

package/dist/cjs/utils/parseUrl-extras.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addUrlOrigin = exports.removeUrlOrigin = exports.modifyUrlPathname = exports.removeBaseServer = exports.normalizeUrlPathname = exports.isBaseAssets = exports.prependBase = void 0;
+exports.isUriWithProtocol = exports.addUrlOrigin = exports.removeUrlOrigin = exports.modifyUrlPathname = exports.removeBaseServer = exports.normalizeUrlPathname = exports.isBaseAssets = exports.prependBase = void 0;
 const parseUrl_js_1 = require("./parseUrl.js");
 const assert_js_1 = require("./assert.js");
 const slice_js_1 = require("./slice.js");
@@ -52,15 +52,20 @@ function isBaseAssets(base) {
     return base.startsWith('/') || base.startsWith('http://') || base.startsWith('https://');
 }
 exports.isBaseAssets = isBaseAssets;
-function normalizeUrlPathname(urlOriginal, trailingSlash) {
+function normalizeUrlPathname(urlOriginal, trailingSlash, baseServer) {
     const urlNormalized = modifyUrlPathname(urlOriginal, (urlPathname) => {
         (0, assert_js_1.assert)(urlPathname.startsWith('/'));
-        let urlPathnameNormalized = '/' + urlPathname.split('/').filter(Boolean).join('/');
-        if (urlPathnameNormalized !== '/') {
-            (0, assert_js_1.assert)(!urlPathnameNormalized.endsWith('/'));
-            if (trailingSlash) {
-                urlPathnameNormalized = urlPathnameNormalized + '/';
-            }
+        let urlPathnameNormalized = normalize(urlPathname);
+        if (urlPathnameNormalized === '/') {
+            return urlPathnameNormalized;
+        }
+        // If the Base URL has a trailing slash, then Vite (as of vite@5.0.0-beta.19) expects the root URL to also have a trailing slash, see https://github.com/vikejs/vike/issues/1258#issuecomment-1812226260
+        if (baseServer.endsWith('/') && baseServer !== '/' && normalize(baseServer) === urlPathnameNormalized) {
+            trailingSlash = true;
+        }
+        (0, assert_js_1.assert)(!urlPathnameNormalized.endsWith('/'));
+        if (trailingSlash) {
+            urlPathnameNormalized = urlPathnameNormalized + '/';
         }
         return urlPathnameNormalized;
     });
@@ -69,6 +74,10 @@ function normalizeUrlPathname(urlOriginal, trailingSlash) {
     return urlNormalized;
 }
 exports.normalizeUrlPathname = normalizeUrlPathname;
+function normalize(urlPathname) {
+    (0, assert_js_1.assert)(urlPathname.startsWith('/'));
+    return '/' + urlPathname.split('/').filter(Boolean).join('/');
+}
 function modifyUrlPathname(url, modifier) {
     const { origin, pathnameOriginal, searchOriginal, hashOriginal } = (0, parseUrl_js_1.parseUrl)(url, '/');
     const pathnameModified = modifier(pathnameOriginal);
@@ -94,3 +103,8 @@ function addUrlOrigin(url, origin) {
     return urlModified;
 }
 exports.addUrlOrigin = addUrlOrigin;
+function isUriWithProtocol(uri) {
+    // https://en.wikipedia.org/wiki/List_of_URI_schemes
+    return /^[a-z0-9][a-z0-9\.\+\-]*:/i.test(uri);
+}
+exports.isUriWithProtocol = isUriWithProtocol;

package/dist/cjs/utils/parseUrl.js

@@ -55,7 +55,7 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);
+    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
     (0, assert_js_1.assert)(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
     (0, assert_js_1.assert)(pathnameResolved.startsWith('/'));
     (0, assert_js_1.assert)(origin === null || url.startsWith(origin));
@@ -91,35 +91,43 @@ function decodeSafe(urlComponent) {
     return urlComponent;
 }
 function decodePathname(urlPathname) {
+    urlPathname = urlPathname.replace(/\s+$/, '');
     urlPathname = urlPathname
         .split('/')
         .map((dir) => decodeSafe(dir).split('/').join('%2F'))
         .join('/');
-    urlPathname = urlPathname.replace(/\s/g, '');
     return urlPathname;
 }
-function parsePathname(urlWithoutHashNorSearch, baseServer) {
+function getPathname(url, baseServer) {
+    // Search and hash already extracted
+    (0, assert_js_1.assert)(!url.includes('?') && !url.includes('#'));
+    // url has origin
     {
-        const { origin, pathname } = parseOrigin(urlWithoutHashNorSearch);
+        const { origin, pathname } = parseOrigin(url);
         if (origin) {
             return { origin, pathname };
         }
-        (0, assert_js_1.assert)(pathname === urlWithoutHashNorSearch);
+        (0, assert_js_1.assert)(pathname === url);
     }
-    if (urlWithoutHashNorSearch.startsWith('/')) {
-        return { origin: null, pathname: urlWithoutHashNorSearch };
+    // url doesn't have origin
+    if (url.startsWith('/')) {
+        return { origin: null, pathname: url };
     }
     else {
-        // In the browser, this is the Base URL of the current URL
+        // url is a relative path
+        // In the browser, this is the Base URL of the current URL.
         // Safe access `window?.document?.baseURI` for users who shim `window` in Node.js
-        let baseURI = typeof window !== 'undefined' && window?.document?.baseURI;
-        if (baseURI)
-            baseURI = parseOrigin(baseURI).pathname;
-        const base = baseURI || baseServer;
-        const pathname = resolveUrlPathnameRelative(urlWithoutHashNorSearch, base);
-        // We need to parse the origin in case `base === window.document.baseURI`
-        const parsed = parseOrigin(pathname);
-        return parsed;
+        const baseURI = typeof window !== 'undefined' ? window?.document?.baseURI : undefined;
+        let base;
+        if (baseURI) {
+            const baseURIPathaname = parseOrigin(baseURI.split('?')[0]).pathname;
+            base = baseURIPathaname;
+        }
+        else {
+            base = baseServer;
+        }
+        const pathname = resolveUrlPathnameRelative(url, base);
+        return { origin: null, pathname };
     }
 }
 function parseOrigin(url) {

package/dist/cjs/utils/projectInfo.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectInfo = void 0;
+exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.146';
+const PROJECT_VERSION = '0.4.147-commit-f9a91f3';
+exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,