vike 0.4.239-commit-33e55d4 → 0.4.239-commit-4d0d950

package/dist/cjs/node/vite/shared/resolveVikeConfigInternal/resolvePointerImport.js

@@ -1,102 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePointerImport = resolvePointerImport;
-exports.resolvePointerImportData = resolvePointerImportData;
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const utils_js_1 = require("../../utils.js");
-const pointerImports_js_1 = require("./pointerImports.js");
-const getFilePath_js_1 = require("../getFilePath.js");
-function resolvePointerImport(configValue, importerFilePath, userRootDir, configName) {
-    if (typeof configValue !== 'string')
-        return null;
-    const pointerImportData = (0, pointerImports_js_1.parsePointerImportData)(configValue);
-    if (!pointerImportData)
-        return null;
-    const { exportName } = pointerImportData;
-    const filePath = resolvePointerImportData(pointerImportData, importerFilePath, userRootDir);
-    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    const fileExportPath = {
-        ...filePath,
-        fileExportName: exportName,
-        fileExportPathToShowToUser,
-    };
-    return { fileExportPath };
-}
-function resolvePointerImportData(pointerImportData, importerFilePath, userRootDir) {
-    const { importPath } = pointerImportData;
-    (0, pointerImports_js_1.assertPointerImportPath)(importPath);
-    const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath, userRootDir);
-    let filePath;
-    (0, utils_js_1.assertPosixPath)(importPath);
-    if ((0, utils_js_1.isImportPathRelative)(importPath) || (0, utils_js_1.isFilePathAbsolute)(importPath)) {
-        // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
-        assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
-        // Pointer imports are included in virtual files, and we need filePathAbsoluteUserRootDir because we didn't find a way to have filesystem absolute import paths in virtual files: https://gist.github.com/brillout/2315231c9a8164f950c64b4b4a7bbd39
-        const errSuffix = `outside of the ${userRootDir} directory which is forbidden: make sure your import paths resolve inside the ${userRootDir} directory, or import from an npm package.`;
-        const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({ filePathAbsoluteFilesystem, userRootDir });
-        if ((0, utils_js_1.isImportPathRelative)(importPath)) {
-            (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `The relative import ${picocolors_1.default.cyan(importPath)} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} ${errSuffix}`);
-        }
-        else {
-            (0, utils_js_1.assert)((0, utils_js_1.isFilePathAbsolute)(importPath));
-            (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `The import path ${importPath} defined by ${importerFilePath.filePathToShowToUser} is ${errSuffix}`);
-        }
-        // Forbid node_modules/ because it's brittle: if node_modules/ lives outside of userRootDir then it crashes.
-        (0, utils_js_1.assertUsage)(!filePathAbsoluteUserRootDir.includes('/node_modules/'), `The import path ${importPath} defined by ${importerFilePath.filePathToShowToUser} resolves to ${filePathAbsoluteFilesystem} inside of node_modules/ which is forbidden: use an npm package import instead.`);
-        filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
-    }
-    else {
-        (0, utils_js_1.assert)((0, utils_js_1.isImportPathNpmPackageOrPathAlias)(importPath));
-        const importPathAbsolute = importPath;
-        if (filePathAbsoluteFilesystem) {
-            filePath = (0, getFilePath_js_1.getFilePathResolved)({
-                userRootDir,
-                filePathAbsoluteFilesystem,
-                importPathAbsolute,
-            });
-        }
-        else {
-            // We cannot resolve path aliases defined only in Vite
-            filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
-                importPathAbsolute,
-            });
-        }
-    }
-    return filePath;
-}
-function resolveImportPathWithNode(pointerImportData, importerFilePath, userRootDir) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
-    (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
-    // filePathAbsoluteFilesystem is null when pointerImportData.importPath is a path alias that Node.js doesn't know about
-    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolveOptional)({
-        importPath: pointerImportData.importPath,
-        importerFilePath: importerFilePathAbsolute,
-        userRootDir,
-    });
-    if (!filePathAbsoluteFilesystem) {
-        (0, utils_js_1.assert)(!(0, utils_js_1.isImportPathRelative)(pointerImportData.importPath));
-        // Libraries don't use path aliases => filePathAbsoluteFilesystem should be defined
-        (0, utils_js_1.assert)(!importerFilePathAbsolute.includes('node_modules'));
-    }
-    return filePathAbsoluteFilesystem;
-}
-function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = pointerImportData;
-    const { filePathToShowToUser } = importerFilePath;
-    if (!filePathAbsoluteFilesystem) {
-        const importPathString = picocolors_1.default.code(`${importPath}`);
-        const errIntro = importStringWasGenerated
-            ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${picocolors_1.default.code(importString)} defined by ${filePathToShowToUser}`;
-        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if ((0, utils_js_1.isImportPathRelative)(importPath)) {
-            (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
-        }
-        else {
-            (0, utils_js_1.assertUsage)(false, `${errIntro2} exist?`);
-        }
-    }
-}

package/dist/cjs/node/vite/shared/resolveVikeConfigInternal/transpileAndExecuteFile.js

@@ -1,425 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transpileAndExecuteFile = transpileAndExecuteFile;
-exports.getConfigBuildErrorFormatted = getConfigBuildErrorFormatted;
-exports.getConfigExecutionErrorIntroMsg = getConfigExecutionErrorIntroMsg;
-exports.isTemporaryBuildFile = isTemporaryBuildFile;
-const esbuild_1 = require("esbuild");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const import_1 = require("@brillout/import");
-const utils_js_1 = require("../../utils.js");
-const pointerImports_js_1 = require("./pointerImports.js");
-const source_map_support_1 = __importDefault(require("source-map-support"));
-const getFilePath_js_1 = require("../getFilePath.js");
-(0, utils_js_1.assertIsNotProductionRuntime)();
-installSourceMapSupport();
-const debug = (0, utils_js_1.createDebugger)('vike:pointer-imports');
-const debugEsbuildResolve = (0, utils_js_1.createDebugger)('vike:esbuild-resolve');
-if (debugEsbuildResolve.isActivated)
-    debugEsbuildResolve('esbuild version', esbuild_1.version);
-async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig, esbuildCache) {
-    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
-    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-    const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    if (esbuildCache.transpileCache[filePathAbsoluteFilesystem]) {
-        return await esbuildCache.transpileCache[filePathAbsoluteFilesystem];
-    }
-    const { promise, resolve } = (0, utils_js_1.genPromise)();
-    esbuildCache.transpileCache[filePathAbsoluteFilesystem] = promise;
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isPlainScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
-    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
-    if (isHeader) {
-        (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${picocolors_1.default.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
-    }
-    let fileExports;
-    if (isExtensionConfig && !isHeader && fileExtension.endsWith('js')) {
-        // This doesn't track dependencies => we should never use this for user land configs
-        fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
-    }
-    else {
-        const transformImports = isHeader ? 'all' : true;
-        const code = await transpileFile(filePath, transformImports, userRootDir, esbuildCache);
-        fileExports = await executeTranspiledFile(filePath, code);
-    }
-    resolve({ fileExports });
-    return { fileExports };
-}
-async function transpileFile(filePath, transformImports, userRootDir, esbuildCache) {
-    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
-    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    if (debug.isActivated)
-        debug('transpile', filePathToShowToUserResolved);
-    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache);
-    if (debug.isActivated)
-        debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
-    let isImportTransformed = false;
-    if (transformImports) {
-        const codeMod = (0, pointerImports_js_1.transformPointerImports)(code, filePathToShowToUserResolved, pointerImports);
-        if (codeMod) {
-            code = codeMod;
-            isImportTransformed = true;
-            if (debug.isActivated)
-                debug(`code, post pointer imports transform (${filePathToShowToUserResolved})`, code);
-        }
-    }
-    if (!isImportTransformed) {
-        if (debug.isActivated)
-            debug(`code, no pointer imports (${filePathToShowToUserResolved})`);
-    }
-    return code;
-}
-async function transpileWithEsbuild(filePath, userRootDir, transformImports, esbuildCache) {
-    const entryFilePath = filePath.filePathAbsoluteFilesystem;
-    const entryFileDir = node_path_1.default.posix.dirname(entryFilePath);
-    const options = {
-        platform: 'node',
-        entryPoints: [entryFilePath],
-        sourcemap: 'inline',
-        write: false,
-        target: ['node14.18', 'node16'],
-        outfile: node_path_1.default.posix.join(
-        // Needed for correct inline source map
-        entryFileDir, 
-        // `write: false` => no file is actually emitted
-        'NEVER_EMITTED.js'),
-        logLevel: 'silent',
-        format: 'esm',
-        absWorkingDir: userRootDir,
-        // Disable tree-shaking to avoid dead-code elimination, so that unused imports aren't removed.
-        // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
-        treeShaking: false,
-        minify: false,
-        metafile: true,
-        bundle: true,
-    };
-    const pointerImports = {};
-    options.plugins = [
-        // Determine whether an import should be:
-        //  - A pointer import
-        //  - Externalized
-        {
-            name: 'vike-esbuild',
-            setup(build) {
-                // https://github.com/brillout/esbuild-playground
-                build.onResolve({ filter: /.*/ }, async (args) => {
-                    if (args.kind !== 'import-statement')
-                        return;
-                    // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
-                    const useEsbuildResolver = 'useEsbuildResolver';
-                    if (args.pluginData?.[useEsbuildResolver])
-                        return;
-                    const { path, ...opts } = args;
-                    opts.pluginData = { [useEsbuildResolver]: true };
-                    let resolved = await build.resolve(path, opts);
-                    if (debugEsbuildResolve.isActivated)
-                        debugEsbuildResolve('args', args);
-                    if (debugEsbuildResolve.isActivated)
-                        debugEsbuildResolve('resolved', resolved);
-                    // Temporary workaround for https://github.com/evanw/esbuild/issues/3973
-                    // - Still required for esbuild@0.24.0 (November 2024).
-                    // - Let's try to remove this workaround again later.
-                    if (resolved.errors.length > 0) {
-                        const resolvedWithNode = (0, utils_js_1.requireResolveOptionalDir)({
-                            importPath: path,
-                            importerDir: (0, utils_js_1.toPosixPath)(args.resolveDir),
-                            userRootDir,
-                        });
-                        if (debugEsbuildResolve.isActivated)
-                            debugEsbuildResolve('resolvedWithNode', resolvedWithNode);
-                        if (resolvedWithNode)
-                            resolved = { path: resolvedWithNode };
-                    }
-                    if (resolved.errors && resolved.errors.length > 0) {
-                        /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs whereas esbuild refers to the source +config.ts file.
-                        pointerImports[args.path] = false
-                        return { external: true }
-                        */
-                        // Let esbuild throw the error
-                        cleanEsbuildErrors(resolved.errors);
-                        return resolved;
-                    }
-                    (0, utils_js_1.assert)(resolved.path);
-                    const importPathResolved = (0, utils_js_1.toPosixPath)(resolved.path);
-                    const importPathOriginal = args.path;
-                    // Esbuild resolves path aliases.
-                    // - Enabling us to use:
-                    //   - assertIsImportPathNpmPackage()
-                    //   - isImportPathNpmPackage(str, { cannotBePathAlias: true })
-                    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(importPathResolved);
-                    //  Should be remove this? See comment below.
-                    const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
-                    const isPointerImport = transformImports === 'all' ||
-                        // .jsx, .vue, .svg, ... => obviously not config code => pointer import
-                        !(0, utils_js_1.isPlainScriptFile)(importPathResolved) ||
-                        // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a config has been set by the user or by a Vike extension).
-                        //  - Should we stop doing this? (And instead let Node.js directly load Vike extensions.)
-                        //    - In principle, we can use the setting 'name' value of Vike extensions.
-                        //      - vike@0.4.162 started soft-requiring Vike extensions to set the name config.
-                        //    - In practice, it seems like it requires some (non-trivial?) refactoring.
-                        isVikeExtensionImport;
-                    (0, utils_js_1.assertPosixPath)(importPathResolved);
-                    // `isNpmPkgImport` => `importPathOriginal` is most likely an npm package import, but it can also be a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir`.
-                    const isNpmPkgImport = (() => {
-                        if (importPathResolved.includes('/node_modules/')) {
-                            // So far I can't think of a use case where this assertion would fail, but let's eventually remove it to avoid artificially restricting the user.
-                            (0, utils_js_1.assert)((0, utils_js_1.isImportPathNpmPackageOrPathAlias)(importPathOriginal));
-                            return true;
-                        }
-                        // Linked npm packages
-                        if (
-                        // Assuming path aliases usually resolve inside `userRootDir`.
-                        // - This isn't always the case: https://github.com/vikejs/vike/issues/2326
-                        !importPathResolved.startsWith(userRootDir) &&
-                            // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
-                            (0, utils_js_1.isImportPathNpmPackageOrPathAlias)(importPathOriginal)) {
-                            return true;
-                        }
-                        return false;
-                    })();
-                    const isExternal = isPointerImport ||
-                        // Performance: npm package imports can be externalized. (We could as well let esbuild transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
-                        isNpmPkgImport;
-                    if (!isExternal) {
-                        // User-land config code (i.e. not runtime code) => let esbuild transpile it
-                        (0, utils_js_1.assert)(!isPointerImport && !isNpmPkgImport);
-                        if (debug.isActivated)
-                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                        return resolved;
-                    }
-                    let importPathTranspiled;
-                    (0, utils_js_1.assertPosixPath)(importPathOriginal);
-                    if ((0, utils_js_1.isImportPathRelative)(importPathOriginal)) {
-                        importPathTranspiled = importPathResolved;
-                    }
-                    else {
-                        // `importPathOriginal` is either:
-                        //  - Npm package import
-                        //  - Path alias
-                        const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({
-                            filePathAbsoluteFilesystem: importPathResolved,
-                            userRootDir,
-                        });
-                        if (filePathAbsoluteUserRootDir && !isNpmPkgImport) {
-                            // `importPathOriginal` is most likely a path alias.
-                            // - We have to use esbuild's path alias resolution, because:
-                            //   - Vike doesn't resolve path aliases at all.
-                            //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
-                            // - Esbuild path alias resolution seems reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
-                            importPathTranspiled = importPathResolved;
-                        }
-                        else {
-                            // `importPathOriginal` is most likely an npm package import.
-                            (0, utils_js_1.assertIsImportPathNpmPackage)(importPathOriginal);
-                            // For improved error messages, let the resolution be handled by Vike or Node.js.
-                            importPathTranspiled = importPathOriginal;
-                        }
-                    }
-                    if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
-                    (0, utils_js_1.assert)(isExternal);
-                    (0, utils_js_1.assert)(
-                    // Import of runtime code => handled by Vike
-                    isPointerImport ||
-                        // Import of config code => loaded by Node.js at build-time
-                        isNpmPkgImport);
-                    pointerImports[importPathTranspiled] = isPointerImport;
-                    return { external: true, path: importPathTranspiled };
-                });
-            },
-        },
-        // Track dependencies
-        {
-            name: 'vike:dependency-tracker',
-            setup(b) {
-                b.onLoad({ filter: /./ }, (args) => {
-                    // We collect the dependency `args.path` in case the build fails (upon build error => error is thrown => no metafile)
-                    let { path } = args;
-                    path = (0, utils_js_1.toPosixPath)(path);
-                    esbuildCache.vikeConfigDependencies.add(path);
-                    return undefined;
-                });
-                /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
-                 *  - Because onLoad() isn't call if the config dependency can't be resolved.
-                 *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
-                 *    ```bash
-                 *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
-                 *    ```
-                 *  - But implementing a fix is complex and isn't worth it.
-                b.onResolve(...)
-                */
-            },
-        },
-    ];
-    let result;
-    try {
-        result = await (0, esbuild_1.build)(options);
-    }
-    catch (err) {
-        await formatBuildErr(err, filePath);
-        throw err;
-    }
-    // Track dependencies
-    (0, utils_js_1.assert)(result.metafile);
-    Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
-        filePathRelative = (0, utils_js_1.toPosixPath)(filePathRelative);
-        (0, utils_js_1.assertPosixPath)(userRootDir);
-        const filePathAbsoluteFilesystem = node_path_1.default.posix.join(userRootDir, filePathRelative);
-        esbuildCache.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    });
-    const code = result.outputFiles[0].text;
-    (0, utils_js_1.assert)(typeof code === 'string');
-    return { code, pointerImports };
-}
-async function executeTranspiledFile(filePath, code) {
-    const { filePathAbsoluteFilesystem } = 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 = getTemporaryBuildFilePath(filePathAbsoluteFilesystem);
-    node_fs_1.default.writeFileSync(filePathTmp, code);
-    const clean = () => node_fs_1.default.unlinkSync(filePathTmp);
-    let fileExports = {};
-    try {
-        fileExports = await executeFile(filePathTmp, filePath);
-    }
-    finally {
-        clean();
-    }
-    return fileExports;
-}
-async function executeFile(filePathToExecuteAbsoluteFilesystem, filePathSourceFile) {
-    let fileExports = {};
-    try {
-        fileExports = await (0, import_1.import_)(filePathToExecuteAbsoluteFilesystem);
-    }
-    catch (err) {
-        triggerPrepareStackTrace(err);
-        const errIntroMsg = getErrIntroMsg('execute', filePathSourceFile);
-        (0, utils_js_1.assert)((0, utils_js_1.isObject)(err));
-        execErrIntroMsg.set(err, errIntroMsg);
-        throw err;
-    }
-    // Return a plain JavaScript object:
-    //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
-    //  - We don't need this special object.
-    fileExports = { ...fileExports };
-    return fileExports;
-}
-const formatted = '_formatted';
-function getConfigBuildErrorFormatted(err) {
-    if (!(0, utils_js_1.isObject)(err))
-        return null;
-    if (!(formatted in err))
-        return null;
-    (0, utils_js_1.assert)(typeof err[formatted] === 'string');
-    return err[formatted];
-}
-async function formatBuildErr(err, filePath) {
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(err) && err.errors);
-    const msgEsbuild = (await (0, esbuild_1.formatMessages)(err.errors, {
-        kind: 'error',
-        color: true,
-    }))
-        .map((m) => m.trim())
-        .join('\n');
-    const msgIntro = getErrIntroMsg('transpile', filePath);
-    err[formatted] = `${msgIntro}\n${msgEsbuild}`;
-}
-const execErrIntroMsg = new WeakMap();
-function getConfigExecutionErrorIntroMsg(err) {
-    if (!(0, utils_js_1.isObject)(err))
-        return null;
-    const errIntroMsg = execErrIntroMsg.get(err);
-    return errIntroMsg ?? null;
-}
-function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    const dirname = node_path_1.default.posix.dirname(filePathAbsoluteFilesystem);
-    const filename = node_path_1.default.posix.basename(filePathAbsoluteFilesystem);
-    // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const filePathTmp = node_path_1.default.posix.join(dirname, `${filename}.build-${(0, utils_js_1.getRandomId)()}.mjs`);
-    (0, utils_js_1.assert)(isTemporaryBuildFile(filePathTmp));
-    return filePathTmp;
-}
-function isTemporaryBuildFile(filePath) {
-    (0, utils_js_1.assertPosixPath)(filePath);
-    const fileName = node_path_1.default.posix.basename(filePath);
-    return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName);
-}
-// TO-DO/next-major-release: remove
-function isHeaderFile(filePath) {
-    (0, utils_js_1.assertPosixPath)(filePath);
-    const fileExtensions = getFileExtensions(filePath);
-    return fileExtensions.includes('h');
-}
-function getFileExtensions(filePath) {
-    const fileExtensions = node_path_1.default.posix.basename(filePath).split('.').slice(1);
-    return fileExtensions;
-}
-function getFileExtension(filePath) {
-    const fileExtensions = node_path_1.default.posix.basename(filePath).split('.').slice(1);
-    return fileExtensions.pop();
-}
-function removeHeaderFileExtension(filePath) {
-    (0, utils_js_1.assertPosixPath)(filePath);
-    const fileName = node_path_1.default.posix.basename(filePath);
-    const fileNameParts = fileName.split('.');
-    const fileNamePartsMod = fileNameParts.filter((p) => p !== 'h');
-    (0, utils_js_1.assert)(fileNamePartsMod.length < fileNameParts.length);
-    const fileNameMod = fileNamePartsMod.join('.');
-    return node_path_1.default.posix.join(node_path_1.default.posix.dirname(filePath), fileNameMod);
-}
-// Needed for the npm package 'source-map-support'. The Error.prepareStackTrace() hook of 'source-map-support' needs to be called before the file containing the source map is removed. The clean() call above removes the transpiled file from disk but it contains the inline source map.
-function triggerPrepareStackTrace(err) {
-    if ((0, utils_js_1.isObject)(err)) {
-        // Accessing err.stack triggers prepareStackTrace()
-        const { stack } = err;
-        // Ensure no compiler removes the line above
-        if (1 + 1 === 3)
-            console.log('I_AM_NEVER_SHOWN' + stack);
-    }
-}
-function getErrIntroMsg(operation, filePath) {
-    const { filePathToShowToUserResolved } = filePath;
-    const msg = [
-        // prettier ignore
-        picocolors_1.default.red(`Failed to ${operation}`),
-        picocolors_1.default.bold(picocolors_1.default.red(filePathToShowToUserResolved)),
-        picocolors_1.default.red(`because:`),
-    ].join(' ');
-    return msg;
-}
-function cleanEsbuildErrors(errors) {
-    errors.forEach((e) => (e.notes = e.notes.filter((note) => 
-    // Remove note:
-    // ```shell
-    // You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
-    // ```
-    //
-    // From error:
-    // ```shell
-    // ✘ [ERROR] Could not resolve "#root/renderer/onRenderHtml_typo" [plugin vike-esbuild]
-    //
-    //    renderer/+config.h.js:1:29:
-    //      1 │ import { onRenderHtml } from "#root/renderer/onRenderHtml_typo"
-    //        ╵                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    //
-    //  You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
-    //
-    // ```
-    !note.text.includes('as external to exclude it from the bundle'))));
-}
-function installSourceMapSupport() {
-    // Don't break Vitest's source mapping
-    if ((0, utils_js_1.isVitest)())
-        return;
-    // How about other test runners?
-    // Should we call installSourceMapSupport() lazily in transpileAndExecuteFile() instead?
-    source_map_support_1.default.install();
-}