vike 0.4.144-commit-e40e9b1 → 0.4.144-commit-d687042

package/dist/cjs/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -41,13 +41,13 @@ async function getPageDeps(config, pageConfigs, isDev) {
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
                 if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
-                    const { filePathAbsolute } = definedAtInfo;
-                    (0, utils_js_1.assert)(filePathAbsolute);
+                    const { filePathAbsoluteFilesystem } = definedAtInfo;
+                    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
-                    entries.push(filePathAbsolute);
+                    entries.push(filePathAbsoluteFilesystem);
                 }
                 else {
-                    // Adding definedAtInfo.filePathAbsolute doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    // Adding definedAtInfo.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
                     const { importPathAbsolute } = definedAtInfo;
                     (0, utils_js_1.assert)(importPathAbsolute);
                     // We need to differentiate between npm package imports and path aliases.

package/dist/cjs/node/plugin/plugins/envVars.js

@@ -37,25 +37,30 @@ function envVarsPlugin() {
             })
                 .forEach(([key, val]) => {
                 const varName = `import.meta.env.${key}`;
-                const publicPrefix = 'PUBLIC_ENV__';
-                const keyPublic = `${publicPrefix}${key}`;
-                const isPrivate = !key.startsWith(publicPrefix);
-                if (isPrivate && isClientSide) {
-                    if (!code.includes(varName))
-                        return;
-                    const filePathToShowToUser = (0, utils_js_1.getFilePathRelativeToUserRootDir)(id, config.root);
-                    const errMsgAddendum = isBuild ? '' : ' (vike will prevent your app from building for production)';
-                    const errMsg = `${varName} used in ${filePathToShowToUser} and therefore included in client-side bundle which can be be a security leak${errMsgAddendum}, remove ${varName} or rename ${key} to ${keyPublic}, see https://vike.dev/env`;
-                    if (isBuild) {
-                        (0, utils_js_1.assertUsage)(false, errMsg);
-                    }
-                    else {
-                        // Only a warning for faster development DX (e.g. when use toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
-                        (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
+                // Security check
+                {
+                    const publicPrefix = 'PUBLIC_ENV__';
+                    const isPrivate = !key.startsWith(publicPrefix);
+                    if (isPrivate && isClientSide) {
+                        if (!code.includes(varName))
+                            return;
+                        const filePathToShowToUser = (0, utils_js_1.getFilePathRelativeToUserRootDir)(id, config.root);
+                        const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+                        const keyPublic = `${publicPrefix}${key}`;
+                        const errMsg = `${varName} is used in client-side file ${filePathToShowToUser} which means that the environment variable ${key} will be included in client-side bundles and, therefore, ${key} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${varName} only in server-side files, or rename ${key} to ${keyPublic}, see https://vike.dev/env`;
+                        if (isBuild) {
+                            (0, utils_js_1.assertUsage)(false, errMsg);
+                        }
+                        else {
+                            // Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
+                            (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
+                        }
                     }
+                    // Double check
+                    (0, utils_js_1.assert)(!(isPrivate && isClientSide) || !isBuild);
                 }
-                (0, utils_js_1.assert)(!(isPrivate && isClientSide) || !isBuild);
-                code = code.replaceAll(varName, JSON.stringify(val));
+                // Apply
+                code = code.replace(new RegExp((0, utils_js_1.escapeRegex)(varName) + '\b', 'g'), JSON.stringify(val));
             });
             // No need for low-resolution source map since line numbers didn't change. (Does Vite do high-resolution column numbers source mapping?)
             return code;

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -117,8 +117,8 @@ function handleHotUpdate(ctx, config, configVike) {
         return virtualModules;
     }
 }
-function isVikeConfigModule(filePathAbsolute) {
-    return getVikeConfig_js_1.vikeConfigDependencies.has(filePathAbsolute);
+function isVikeConfigModule(filePathAbsoluteFilesystem) {
+    return getVikeConfig_js_1.vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
 function reloadConfig(filePath, config, configVike, op) {
     {

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getFilePathToShowToUser.js

@@ -9,7 +9,7 @@ if (f.filePathRelativeToUserRootDir === null) {
 }
 //*/
 function getFilePathToShowToUser(filePath) {
-    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
+    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsoluteFilesystem;
     (0, utils_js_1.assert)(filePathToShowToUser);
     return filePathToShowToUser;
 }

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -86,9 +86,9 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
     });
     let interfaceFilesByLocationId = {};
     // Config files
-    await Promise.all(configFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
+    await Promise.all(configFiles.map(async ({ filePathAbsoluteFilesystem, filePathRelativeToUserRootDir }) => {
         const configFilePath = {
-            filePathAbsolute: filePathAbsolute,
+            filePathAbsoluteFilesystem: filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
             importPathAbsolute: null
         };
@@ -103,13 +103,13 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         });
     }));
     // Value files
-    await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
+    await Promise.all(valueFiles.map(async ({ filePathAbsoluteFilesystem, filePathRelativeToUserRootDir }) => {
         const configName = getConfigName(filePathRelativeToUserRootDir);
         (0, utils_js_1.assert)(configName);
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
-                filePathAbsolute,
+                filePathAbsoluteFilesystem,
                 importPathAbsolute: null
             },
             configMap: {
@@ -551,20 +551,20 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     if (!importData)
         return null;
     const { importPath, exportName } = importData;
-    const filePathAbsolute = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsolute ?? importPath, configEnv, configName);
+    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
     const fileExportPath = exportName === 'default' || exportName === configName ? [] : [exportName];
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
         // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
         // ```
-        assertImportPath(filePathAbsolute, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
+        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
         return {
             exportName,
             fileExportPath,
-            filePathAbsolute,
+            filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir,
             importPathAbsolute: null
         };
@@ -576,26 +576,26 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         return {
             exportName,
             fileExportPath,
-            filePathAbsolute,
+            filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir: null,
             importPathAbsolute: importPath
         };
     }
 }
-function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
+function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
     let filePathRelativeToUserRootDir;
-    if (filePathAbsolute.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
     }
     else {
         (0, utils_js_1.assertUsage)(false, `${(0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath)} imports from a relative path ${picocolors_1.default.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
         // None of the following works. Seems to be a Vite bug?
         // /*
-        // assert(filePathAbsolute.startsWith('/'))
-        // filePath = `/@fs${filePathAbsolute}`
+        // assert(filePathAbsoluteFilesystem.startsWith('/'))
+        // filePath = `/@fs${filePathAbsoluteFilesystem}`
         // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute)
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
         // assert(filePathRelativeToUserRootDir.startsWith('../'))
         // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
         // //*/
@@ -604,11 +604,11 @@ function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, c
     (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
     return filePathRelativeToUserRootDir;
 }
-function getVitePathFromAbsolutePath(filePathAbsolute, root) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
+function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, utils_js_1.assertPosixPath)(root);
-    (0, utils_js_1.assert)(filePathAbsolute.startsWith(root));
-    let vitePath = path_1.default.posix.relative(root, filePathAbsolute);
+    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(root));
+    let vitePath = path_1.default.posix.relative(root, filePathAbsoluteFilesystem);
     (0, utils_js_1.assert)(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
     vitePath = '/' + vitePath;
     return vitePath;
@@ -761,8 +761,8 @@ async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
     const plusFiles = result.map((p) => {
         p = (0, utils_js_1.toPosixPath)(p);
         const filePathRelativeToUserRootDir = path_1.default.posix.join('/', p);
-        const filePathAbsolute = path_1.default.posix.join(userRootDir, p);
-        return { filePathRelativeToUserRootDir, filePathAbsolute };
+        const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, p);
+        return { filePathRelativeToUserRootDir, filePathAbsoluteFilesystem };
     });
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
@@ -774,7 +774,7 @@ async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
             const { importPath, filePath } = pageConfigDistFile;
             plusFiles.push({
                 filePathRelativeToUserRootDir: importPath,
-                filePathAbsolute: filePath
+                filePathAbsoluteFilesystem: filePath
             });
         });
     });
@@ -804,12 +804,12 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     (0, utils_js_1.assertUsage)(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
 }
 async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsolute } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
     const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
-        filePathAbsolute
+        filePathAbsoluteFilesystem
     ]);
     const configFile = {
         fileExports,
@@ -818,13 +818,13 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     };
     return { configFile, extendsConfigs };
 }
-function assertNoInfiniteLoop(visited, filePathAbsolute) {
-    const idx = visited.indexOf(filePathAbsolute);
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
     if (idx === -1)
         return;
     const loop = visited.slice(idx);
-    (0, utils_js_1.assert)(loop[0] === filePathAbsolute);
-    (0, utils_js_1.assertUsage)(idx === -1, `Infinite extends loop ${[...loop, filePathAbsolute].join('>')}`);
+    (0, utils_js_1.assert)(loop[0] === filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertUsage)(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
 async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
@@ -833,14 +833,14 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         const { importPath: importPath } = importData;
         // TODO
         //  - validate extends configs
-        const filePathAbsolute = resolveImportPath(importData, configFilePath);
-        assertImportPath(filePathAbsolute, importData, configFilePath);
-        assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
+        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
+        assertExtendsImportPath(importPath, filePathAbsoluteFilesystem, configFilePath);
         // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir);
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
         extendsConfigFiles.push({
-            filePathAbsolute,
+            filePathAbsoluteFilesystem,
             // TODO: fix type cast
             filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
             importPathAbsolute: importPath
@@ -852,16 +852,16 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);
     }));
-    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsolute);
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
+function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    if (!filePathAbsolute.startsWith(userRootDir)) {
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         return null;
     }
-    let filePathRelativeToUserRootDir = filePathAbsolute.slice(userRootDir.length);
+    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
     if (!filePathRelativeToUserRootDir.startsWith('/'))
         filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
     return filePathRelativeToUserRootDir;
@@ -1021,17 +1021,17 @@ function determineIsErrorPage(routeFilesystem) {
     return routeFilesystem.split('/').includes('_error');
 }
 function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
     const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
-    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
-    const filePathAbsolute = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
-    return filePathAbsolute;
+    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
 }
-function assertImportPath(filePathAbsolute, importData, importerFilePath) {
+function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
     const { importPath: importPath, importStringWasGenerated, importString } = importData;
     const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(importerFilePath);
-    if (!filePathAbsolute) {
+    if (!filePathAbsoluteFilesystem) {
         const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
         const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/transpileAndExecuteFile.js

@@ -23,9 +23,9 @@ async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
 }
 exports.transpileAndExecuteFile = transpileAndExecuteFile;
 async function transpileFile(filePath, isValueFile, userRootDir) {
-    const { filePathAbsolute } = filePath;
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
-    getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = filePath;
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
     let fileImports = null;
     {
@@ -39,9 +39,9 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
 }
 function transpileImports(codeOriginal, filePath, isValueFile) {
     // Do we need to remove the imports?
-    const { filePathAbsolute } = filePath;
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
-    const isHeader = isHeaderFile(filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = filePath;
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     const isPageConfigFile = !isValueFile;
     if (!isHeader && !isPageConfigFile) {
         return null;
@@ -63,7 +63,7 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     return { code, fileImports };
 }
 async function transpileWithEsbuild(filePath, bundle, userRootDir) {
-    const entryFilePath = filePath.filePathAbsolute;
+    const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path_1.default.posix.dirname(entryFilePath);
     const options = {
         platform: 'node',
@@ -128,8 +128,8 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
             (0, utils_js_1.assertPosixPath)(userRootDir);
-            const filePathAbsolute = path_1.default.posix.join(userRootDir, filePathRelative);
-            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsolute);
+            const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathRelative);
+            getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
         });
     }
     const code = result.outputFiles[0].text;
@@ -137,10 +137,10 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     return code;
 }
 async function executeFile(filePath, code, fileImports, isValueFile) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = filePath;
+    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
-    const filePathTmp = getFilePathTmp(filePathAbsolute);
+    const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
     fs_1.default.writeFileSync(filePathTmp, code);
     const clean = () => fs_1.default.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -163,7 +163,7 @@ async function executeFile(filePath, code, fileImports, isValueFile) {
     fileExports = { ...fileExports };
     if (fileImports && !isValueFile) {
         (0, utils_js_1.assert)(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsoluteFilesystem;
         assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
     }
     return { fileExports };

package/dist/cjs/utils/getFilePathAbsolute.js

@@ -34,27 +34,27 @@ function getFilePathAbsolute(filePath, config) {
         filePathUnresolved = path_1.default.posix.join(root, filePath);
         (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathUnresolved);
     }
-    let filePathAbsolute;
+    let filePathAbsoluteFilesystem;
     try {
-        filePathAbsolute = require_.resolve(filePathUnresolved, { paths: [config.root] });
+        filePathAbsoluteFilesystem = require_.resolve(filePathUnresolved, { paths: [config.root] });
     }
     catch (err) {
         console.error(err);
         (0, assert_js_1.assert)(false);
     }
-    filePathAbsolute = (0, filesystemPathHandling_js_1.toPosixPath)(filePathAbsolute);
-    (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathAbsolute);
-    return filePathAbsolute;
+    filePathAbsoluteFilesystem = (0, filesystemPathHandling_js_1.toPosixPath)(filePathAbsoluteFilesystem);
+    (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    return filePathAbsoluteFilesystem;
 }
 exports.getFilePathAbsolute = getFilePathAbsolute;
-function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
-    (0, filesystemPathHandling_js_1.assertPosixPath)(filePathAbsolute);
+function getFilePathRelativeToUserRootDir(filePathAbsoluteFilesystem, userRootDir, alwaysRelative = false) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, filesystemPathHandling_js_1.assertPosixPath)(userRootDir);
-    let filePathRelativeToUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsolute);
-    if (filePathAbsolute.startsWith(userRootDir)) {
+    let filePathRelativeToUserRootDir = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         (0, assert_js_1.assert)(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
         // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
-        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        { filePathRelativeToUserRootDir, filePathAbsoluteFilesystem, userRootDir });
         filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
         return filePathRelativeToUserRootDir;
     }
@@ -63,7 +63,7 @@ function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysR
             return filePathRelativeToUserRootDir;
         }
         else {
-            return filePathAbsolute;
+            return filePathAbsoluteFilesystem;
         }
     }
 }

package/dist/cjs/utils/parseUrl.js

@@ -52,7 +52,7 @@ function parseUrl(url, baseServer) {
     const searchAll = {};
     Array.from(new URLSearchParams(searchOriginal || '')).forEach(([key, val]) => {
         search[key] = val;
-        searchAll[key] = [...(searchAll[key] || []), val];
+        searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
     const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.144-commit-e40e9b1';
+const PROJECT_VERSION = '0.4.144-commit-d687042';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -1,7 +1,7 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs, } from '../utils.js';
+import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, getOutDirs } from '../utils.js';
 import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/utils.js';

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -38,13 +38,13 @@ async function getPageDeps(config, pageConfigs, isDev) {
                 if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
                     return;
                 if (definedAtInfo.filePathRelativeToUserRootDir !== null) {
-                    const { filePathAbsolute } = definedAtInfo;
-                    assert(filePathAbsolute);
+                    const { filePathAbsoluteFilesystem } = definedAtInfo;
+                    assert(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
-                    entries.push(filePathAbsolute);
+                    entries.push(filePathAbsoluteFilesystem);
                 }
                 else {
-                    // Adding definedAtInfo.filePathAbsolute doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    // Adding definedAtInfo.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
                     const { importPathAbsolute } = definedAtInfo;
                     assert(importPathAbsolute);
                     // We need to differentiate between npm package imports and path aliases.

package/dist/esm/node/plugin/plugins/envVars.js

@@ -1,6 +1,6 @@
 export { envVarsPlugin };
 import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -35,25 +35,30 @@ function envVarsPlugin() {
             })
                 .forEach(([key, val]) => {
                 const varName = `import.meta.env.${key}`;
-                const publicPrefix = 'PUBLIC_ENV__';
-                const keyPublic = `${publicPrefix}${key}`;
-                const isPrivate = !key.startsWith(publicPrefix);
-                if (isPrivate && isClientSide) {
-                    if (!code.includes(varName))
-                        return;
-                    const filePathToShowToUser = getFilePathRelativeToUserRootDir(id, config.root);
-                    const errMsgAddendum = isBuild ? '' : ' (vike will prevent your app from building for production)';
-                    const errMsg = `${varName} used in ${filePathToShowToUser} and therefore included in client-side bundle which can be be a security leak${errMsgAddendum}, remove ${varName} or rename ${key} to ${keyPublic}, see https://vike.dev/env`;
-                    if (isBuild) {
-                        assertUsage(false, errMsg);
-                    }
-                    else {
-                        // Only a warning for faster development DX (e.g. when use toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
-                        assertWarning(false, errMsg, { onlyOnce: true });
+                // Security check
+                {
+                    const publicPrefix = 'PUBLIC_ENV__';
+                    const isPrivate = !key.startsWith(publicPrefix);
+                    if (isPrivate && isClientSide) {
+                        if (!code.includes(varName))
+                            return;
+                        const filePathToShowToUser = getFilePathRelativeToUserRootDir(id, config.root);
+                        const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+                        const keyPublic = `${publicPrefix}${key}`;
+                        const errMsg = `${varName} is used in client-side file ${filePathToShowToUser} which means that the environment variable ${key} will be included in client-side bundles and, therefore, ${key} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${varName} only in server-side files, or rename ${key} to ${keyPublic}, see https://vike.dev/env`;
+                        if (isBuild) {
+                            assertUsage(false, errMsg);
+                        }
+                        else {
+                            // Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`)
+                            assertWarning(false, errMsg, { onlyOnce: true });
+                        }
                     }
+                    // Double check
+                    assert(!(isPrivate && isClientSide) || !isBuild);
                 }
-                assert(!(isPrivate && isClientSide) || !isBuild);
-                code = code.replaceAll(varName, JSON.stringify(val));
+                // Apply
+                code = code.replace(new RegExp(escapeRegex(varName) + '\b', 'g'), JSON.stringify(val));
             });
             // No need for low-resolution source map since line numbers didn't change. (Does Vite do high-resolution column numbers source mapping?)
             return code;

package/dist/esm/node/plugin/plugins/importUserCode/index.js

@@ -111,8 +111,8 @@ function handleHotUpdate(ctx, config, configVike) {
         return virtualModules;
     }
 }
-function isVikeConfigModule(filePathAbsolute) {
-    return vikeConfigDependencies.has(filePathAbsolute);
+function isVikeConfigModule(filePathAbsoluteFilesystem) {
+    return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
 function reloadConfig(filePath, config, configVike, op) {
     {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getFilePathToShowToUser.d.ts

@@ -5,7 +5,7 @@ type FilePath = {
      *
      * Example: `/home/rom/code/my-app/pages/some-page/Page.js`
      */
-    filePathAbsolute: string;
+    filePathAbsoluteFilesystem: string;
 } & ({
     /** The file's path relative to the Vite's root (i.e. the user's project root directory).
      *

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getFilePathToShowToUser.js

@@ -7,7 +7,7 @@ if (f.filePathRelativeToUserRootDir === null) {
 }
 //*/
 function getFilePathToShowToUser(filePath) {
-    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
+    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsoluteFilesystem;
     assert(filePathToShowToUser);
     return filePathToShowToUser;
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -81,9 +81,9 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
     });
     let interfaceFilesByLocationId = {};
     // Config files
-    await Promise.all(configFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
+    await Promise.all(configFiles.map(async ({ filePathAbsoluteFilesystem, filePathRelativeToUserRootDir }) => {
         const configFilePath = {
-            filePathAbsolute: filePathAbsolute,
+            filePathAbsoluteFilesystem: filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
             importPathAbsolute: null
         };
@@ -98,13 +98,13 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
         });
     }));
     // Value files
-    await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
+    await Promise.all(valueFiles.map(async ({ filePathAbsoluteFilesystem, filePathRelativeToUserRootDir }) => {
         const configName = getConfigName(filePathRelativeToUserRootDir);
         assert(configName);
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
-                filePathAbsolute,
+                filePathAbsoluteFilesystem,
                 importPathAbsolute: null
             },
             configMap: {
@@ -546,20 +546,20 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     if (!importData)
         return null;
     const { importPath, exportName } = importData;
-    const filePathAbsolute = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsolute ?? importPath, configEnv, configName);
+    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
     const fileExportPath = exportName === 'default' || exportName === configName ? [] : [exportName];
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
         // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
         // ```
-        assertImportPath(filePathAbsolute, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
+        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
         return {
             exportName,
             fileExportPath,
-            filePathAbsolute,
+            filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir,
             importPathAbsolute: null
         };
@@ -571,26 +571,26 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         return {
             exportName,
             fileExportPath,
-            filePathAbsolute,
+            filePathAbsoluteFilesystem,
             filePathRelativeToUserRootDir: null,
             importPathAbsolute: importPath
         };
     }
 }
-function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
+function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
     let filePathRelativeToUserRootDir;
-    if (filePathAbsolute.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
     }
     else {
         assertUsage(false, `${getFilePathToShowToUser(configFilePath)} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
         // None of the following works. Seems to be a Vite bug?
         // /*
-        // assert(filePathAbsolute.startsWith('/'))
-        // filePath = `/@fs${filePathAbsolute}`
+        // assert(filePathAbsoluteFilesystem.startsWith('/'))
+        // filePath = `/@fs${filePathAbsoluteFilesystem}`
         // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute)
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
         // assert(filePathRelativeToUserRootDir.startsWith('../'))
         // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
         // //*/
@@ -599,11 +599,11 @@ function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, c
     assert(filePathRelativeToUserRootDir.startsWith('/'));
     return filePathRelativeToUserRootDir;
 }
-function getVitePathFromAbsolutePath(filePathAbsolute, root) {
-    assertPosixPath(filePathAbsolute);
+function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
+    assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(root);
-    assert(filePathAbsolute.startsWith(root));
-    let vitePath = path.posix.relative(root, filePathAbsolute);
+    assert(filePathAbsoluteFilesystem.startsWith(root));
+    let vitePath = path.posix.relative(root, filePathAbsoluteFilesystem);
     assert(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
     vitePath = '/' + vitePath;
     return vitePath;
@@ -756,8 +756,8 @@ async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
     const plusFiles = result.map((p) => {
         p = toPosixPath(p);
         const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        const filePathAbsolute = path.posix.join(userRootDir, p);
-        return { filePathRelativeToUserRootDir, filePathAbsolute };
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+        return { filePathRelativeToUserRootDir, filePathAbsoluteFilesystem };
     });
     extensions.forEach((extension) => {
         extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
@@ -769,7 +769,7 @@ async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
             const { importPath, filePath } = pageConfigDistFile;
             plusFiles.push({
                 filePathRelativeToUserRootDir: importPath,
-                filePathAbsolute: filePath
+                filePathAbsoluteFilesystem: filePath
             });
         });
     });
@@ -799,12 +799,12 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     assertUsage(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
 }
 async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsolute } = configFilePath;
-    assertNoInfiniteLoop(visited, filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
     const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
-        filePathAbsolute
+        filePathAbsoluteFilesystem
     ]);
     const configFile = {
         fileExports,
@@ -813,13 +813,13 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     };
     return { configFile, extendsConfigs };
 }
-function assertNoInfiniteLoop(visited, filePathAbsolute) {
-    const idx = visited.indexOf(filePathAbsolute);
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
     if (idx === -1)
         return;
     const loop = visited.slice(idx);
-    assert(loop[0] === filePathAbsolute);
-    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsolute].join('>')}`);
+    assert(loop[0] === filePathAbsoluteFilesystem);
+    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
 async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
@@ -828,14 +828,14 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         const { importPath: importPath } = importData;
         // TODO
         //  - validate extends configs
-        const filePathAbsolute = resolveImportPath(importData, configFilePath);
-        assertImportPath(filePathAbsolute, importData, configFilePath);
-        assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
+        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
+        assertExtendsImportPath(importPath, filePathAbsoluteFilesystem, configFilePath);
         // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir);
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
         extendsConfigFiles.push({
-            filePathAbsolute,
+            filePathAbsoluteFilesystem,
             // TODO: fix type cast
             filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
             importPathAbsolute: importPath
@@ -847,16 +847,16 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);
     }));
-    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsolute);
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir) {
-    assertPosixPath(filePathAbsolute);
+function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
+    assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
-    if (!filePathAbsolute.startsWith(userRootDir)) {
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         return null;
     }
-    let filePathRelativeToUserRootDir = filePathAbsolute.slice(userRootDir.length);
+    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
     if (!filePathRelativeToUserRootDir.startsWith('/'))
         filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
     return filePathRelativeToUserRootDir;
@@ -1016,17 +1016,17 @@ function determineIsErrorPage(routeFilesystem) {
     return routeFilesystem.split('/').includes('_error');
 }
 function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
-    const filePathAbsolute = requireResolve(importData.importPath, cwd);
-    return filePathAbsolute;
+    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
 }
-function assertImportPath(filePathAbsolute, importData, importerFilePath) {
+function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
     const { importPath: importPath, importStringWasGenerated, importString } = importData;
     const filePathToShowToUser = getFilePathToShowToUser(importerFilePath);
-    if (!filePathAbsolute) {
+    if (!filePathAbsoluteFilesystem) {
         const importPathString = pc.cyan(`'${importPath}'`);
         const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/transpileAndExecuteFile.js

@@ -20,9 +20,9 @@ async function transpileAndExecuteFile(filePath, isValueFile, userRootDir) {
     return { fileExports };
 }
 async function transpileFile(filePath, isValueFile, userRootDir) {
-    const { filePathAbsolute } = filePath;
-    assertPosixPath(filePathAbsolute);
-    vikeConfigDependencies.add(filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = filePath;
+    assertPosixPath(filePathAbsoluteFilesystem);
+    vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     let code = await transpileWithEsbuild(filePath, isValueFile, userRootDir);
     let fileImports = null;
     {
@@ -36,9 +36,9 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
 }
 function transpileImports(codeOriginal, filePath, isValueFile) {
     // Do we need to remove the imports?
-    const { filePathAbsolute } = filePath;
-    assertPosixPath(filePathAbsolute);
-    const isHeader = isHeaderFile(filePathAbsolute);
+    const { filePathAbsoluteFilesystem } = filePath;
+    assertPosixPath(filePathAbsoluteFilesystem);
+    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     const isPageConfigFile = !isValueFile;
     if (!isHeader && !isPageConfigFile) {
         return null;
@@ -60,7 +60,7 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     return { code, fileImports };
 }
 async function transpileWithEsbuild(filePath, bundle, userRootDir) {
-    const entryFilePath = filePath.filePathAbsolute;
+    const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path.posix.dirname(entryFilePath);
     const options = {
         platform: 'node',
@@ -125,8 +125,8 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = toPosixPath(filePathRelative);
             assertPosixPath(userRootDir);
-            const filePathAbsolute = path.posix.join(userRootDir, filePathRelative);
-            vikeConfigDependencies.add(filePathAbsolute);
+            const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelative);
+            vikeConfigDependencies.add(filePathAbsoluteFilesystem);
         });
     }
     const code = result.outputFiles[0].text;
@@ -134,10 +134,10 @@ async function transpileWithEsbuild(filePath, bundle, userRootDir) {
     return code;
 }
 async function executeFile(filePath, code, fileImports, isValueFile) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = filePath;
+    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
-    const filePathTmp = getFilePathTmp(filePathAbsolute);
+    const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
     fs.writeFileSync(filePathTmp, code);
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -160,7 +160,7 @@ async function executeFile(filePath, code, fileImports, isValueFile) {
     fileExports = { ...fileExports };
     if (fileImports && !isValueFile) {
         assert(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsolute;
+        const filePathToShowToUser = filePathRelativeToUserRootDir ?? filePathAbsoluteFilesystem;
         assertImportsAreReExported(fileImports, fileExports, filePathToShowToUser);
     }
     return { fileExports };

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -93,11 +93,11 @@ type DefinedAtFile = {
 type DefinedAtFileInfo = // TODO: replace filePathRelativeToUserRootDir and importPathAbsolute with following?
 ({
     filePathRelativeToUserRootDir: string;
-    filePathAbsolute: string;
+    filePathAbsoluteFilesystem: string;
     importPathAbsolute: null;
 } | {
     filePathRelativeToUserRootDir: null;
-    filePathAbsolute: string | null;
+    filePathAbsoluteFilesystem: string | null;
     importPathAbsolute: string;
 }) & {
     exportName?: string;

package/dist/esm/utils/getFilePathAbsolute.d.ts

@@ -2,4 +2,4 @@ export { getFilePathAbsolute };
 export { getFilePathRelativeToUserRootDir };
 import type { ResolvedConfig } from 'vite';
 declare function getFilePathAbsolute(filePath: string, config: ResolvedConfig): string;
-declare function getFilePathRelativeToUserRootDir(filePathAbsolute: string, userRootDir: string, alwaysRelative?: boolean): string;
+declare function getFilePathRelativeToUserRootDir(filePathAbsoluteFilesystem: string, userRootDir: string, alwaysRelative?: boolean): string;

package/dist/esm/utils/getFilePathAbsolute.js

@@ -30,26 +30,26 @@ function getFilePathAbsolute(filePath, config) {
         filePathUnresolved = path.posix.join(root, filePath);
         assertPathIsFilesystemAbsolute(filePathUnresolved);
     }
-    let filePathAbsolute;
+    let filePathAbsoluteFilesystem;
     try {
-        filePathAbsolute = require_.resolve(filePathUnresolved, { paths: [config.root] });
+        filePathAbsoluteFilesystem = require_.resolve(filePathUnresolved, { paths: [config.root] });
     }
     catch (err) {
         console.error(err);
         assert(false);
     }
-    filePathAbsolute = toPosixPath(filePathAbsolute);
-    assertPathIsFilesystemAbsolute(filePathAbsolute);
-    return filePathAbsolute;
+    filePathAbsoluteFilesystem = toPosixPath(filePathAbsoluteFilesystem);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    return filePathAbsoluteFilesystem;
 }
-function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
-    assertPosixPath(filePathAbsolute);
+function getFilePathRelativeToUserRootDir(filePathAbsoluteFilesystem, userRootDir, alwaysRelative = false) {
+    assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
-    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute);
-    if (filePathAbsolute.startsWith(userRootDir)) {
+    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         assert(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
         // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
-        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        { filePathRelativeToUserRootDir, filePathAbsoluteFilesystem, userRootDir });
         filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
         return filePathRelativeToUserRootDir;
     }
@@ -58,7 +58,7 @@ function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysR
             return filePathRelativeToUserRootDir;
         }
         else {
-            return filePathAbsolute;
+            return filePathAbsoluteFilesystem;
         }
     }
 }

package/dist/esm/utils/parseUrl.js

@@ -51,7 +51,7 @@ function parseUrl(url, baseServer) {
     const searchAll = {};
     Array.from(new URLSearchParams(searchOriginal || '')).forEach(([key, val]) => {
         search[key] = val;
-        searchAll[key] = [...(searchAll[key] || []), val];
+        searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
     const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);

package/dist/esm/utils/projectInfo.d.ts

@@ -5,7 +5,7 @@ type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.144-commit-e40e9b1";
+    projectVersion: "0.4.144-commit-d687042";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.144-commit-e40e9b1';
+const PROJECT_VERSION = '0.4.144-commit-d687042';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.144-commit-e40e9b1",
+  "version": "0.4.144-commit-d687042",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -162,7 +162,6 @@
     "vike": "./node/cli/bin-entry.js"
   },
   "devDependencies": {
-    "@brillout/part-regex": "^0.1.2",
     "@brillout/release-me": "^0.1.8",
     "@types/estree": "^1.0.0",
     "@types/jest": "^27.4.1",