vike 0.4.249-commit-f416149 → 0.4.249-commit-92f1383

package/dist/node/vite/index.js

@@ -22,6 +22,7 @@ import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModul
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstantsPageContext } from './plugins/pluginReplaceConstantsPageContext.js';
 import { pluginReplaceConstantsGlobalThis } from './plugins/pluginReplaceConstantsGlobalThis.js';
+import { pluginStaticReplace } from './plugins/pluginStaticReplace.js';
 import { pluginViteRPC } from './plugins/non-runnable-dev/pluginViteRPC.js';
 import { pluginBuildApp } from './plugins/build/pluginBuildApp.js';
 import { pluginDistPackageJsonFile } from './plugins/build/pluginDistPackageJsonFile.js';
@@ -33,7 +34,7 @@ import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
-import { isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
+import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
@@ -42,6 +43,7 @@ function plugin(vikeVitePluginOptions = {}) {
     const promise = (async () => {
         if (skip())
             return [];
+        const vikeConfig = await getVikeConfigInternalEarly();
         const plugins = [
             ...pluginCommon(vikeVitePluginOptions),
             ...pluginVirtualFiles(),
@@ -58,8 +60,9 @@ function plugin(vikeVitePluginOptions = {}) {
             ...pluginWorkaroundVite6HmrRegression(),
             ...pluginReplaceConstantsPageContext(),
             ...pluginReplaceConstantsGlobalThis(),
+            ...pluginStaticReplace(vikeConfig),
             ...pluginNonRunnabeDev(),
-            ...(await pluginViteConfigVikeExtensions()),
+            ...(await pluginViteConfigVikeExtensions(vikeConfig)),
         ];
         return plugins;
     })();

package/dist/node/vite/plugins/pluginReplaceConstantsPageContext.js

@@ -11,6 +11,7 @@ const constantsIsClientSide = [
 ];
 // - See https://vike.dev/pageContext#narrowing-down
 // - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because of https://github.com/rolldown/rolldown/issues/4300
+// filterRolldown
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'Context.isClientSide';
 assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));

package/dist/node/vite/plugins/pluginStaticReplace/applyStaticReplace.d.ts

@@ -0,0 +1,123 @@
+export { applyStaticReplace };
+export type { StaticReplace };
+/**
+ * Condition to match an argument value.
+ * - string starting with 'import:' matches an imported identifier
+ * - { prop, equals } matches a property value inside an object argument
+ * - { call, args } matches a call expression with specific arguments
+ * - { member, object, property } matches a member expression like $setup["ClientOnly"]
+ */
+type ArgCondition = string | {
+    prop: string;
+    equals: unknown;
+} | {
+    call: string;
+    args?: Record<number, ArgCondition>;
+} | {
+    member: true;
+    object: string;
+    property: string | ArgCondition;
+};
+/**
+ * Target for replace operation.
+ */
+type ReplaceTarget = {
+    with: unknown;
+} | {
+    arg: number;
+    prop: string;
+    with: unknown;
+} | {
+    arg: number;
+    with: unknown;
+} | {
+    argsFrom: number;
+    with: unknown;
+};
+/**
+ * Target for remove operation.
+ */
+type RemoveTarget = {
+    arg: number;
+    prop: string;
+} | {
+    arg: number;
+} | {
+    argsFrom: number;
+};
+/**
+ * Rule for static replacement/removal.
+ *
+ * @example
+ * // jsx/jsxs/jsxDEV: replace children prop with null
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: ['jsx', 'jsxs', 'jsxDEV'],
+ *     args: { 0: 'import:vike-react/ClientOnly:ClientOnly' }
+ *   },
+ *   replace: { arg: 1, prop: 'children', with: null }
+ * }
+ *
+ * @example
+ * // createElement: remove all children (args from index 2)
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: 'createElement',
+ *     args: { 0: 'import:vike-react/ClientOnly:ClientOnly' }
+ *   },
+ *   remove: { argsFrom: 2 }
+ * }
+ *
+ * @example
+ * // ssrRenderComponent: match nested call expression and remove default slot
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: 'import:vue/server-renderer:ssrRenderComponent',
+ *     args: {
+ *       0: {
+ *         call: 'import:vue:unref',
+ *         args: { 0: 'import:vike-vue/ClientOnly:ClientOnly' }
+ *       }
+ *     }
+ *   },
+ *   remove: { arg: 2, prop: 'default' }
+ * }
+ */
+type StaticReplace = {
+    /** Type of transformation - currently only 'call' is supported, but can be extended in the future */
+    type?: 'call';
+    /** Environment filter: 'client' = client only, 'server' = everything except client */
+    env?: 'server' | 'client';
+    /** Match criteria */
+    match: {
+        /**
+         * Function name(s) to match.
+         * - Plain string: matches function name directly (e.g., 'jsx')
+         * - Import string: 'import:importPath:exportName' (e.g., 'import:react/jsx-runtime:jsx')
+         */
+        function: string | string[];
+        /** Conditions on arguments: index -> condition */
+        args?: Record<number, ArgCondition>;
+    };
+    /** Replace target (optional) */
+    replace?: ReplaceTarget;
+    /** Remove target (optional) */
+    remove?: RemoveTarget;
+};
+type TransformResult = {
+    code: string;
+    map: any;
+} | null;
+type TransformInput = {
+    code: string;
+    id: string;
+    env: string;
+    options: StaticReplace[];
+};
+declare function applyStaticReplace({ code, id, env, options }: TransformInput): Promise<TransformResult>;

package/dist/node/vite/plugins/pluginStaticReplace/applyStaticReplace.js

@@ -0,0 +1,404 @@
+export { applyStaticReplace };
+import { transformAsync } from '@babel/core';
+import * as t from '@babel/types';
+import { parseImportString } from '../../shared/importString.js';
+async function applyStaticReplace({ code, id, env, options }) {
+    // 'server' means "not client" (covers ssr, cloudflare, etc.)
+    const filteredRules = options.filter((rule) => {
+        if (!rule.env)
+            return true;
+        if (rule.env === 'client')
+            return env === 'client';
+        if (rule.env === 'server')
+            return env !== 'client';
+        return false;
+    });
+    if (filteredRules.length === 0) {
+        return null;
+    }
+    try {
+        const state = {
+            modified: false,
+            imports: new Map(),
+            alreadyUnreferenced: new Set(),
+        };
+        const result = await transformAsync(code, {
+            filename: id,
+            ast: true,
+            sourceMaps: true,
+            plugins: [collectImportsPlugin(state), applyRulesPlugin(state, filteredRules), removeUnreferencedPlugin(state)],
+        });
+        if (!result?.code || !state.modified) {
+            return null;
+        }
+        return { code: result.code, map: result.map };
+    }
+    catch (error) {
+        console.error(`Error transforming ${id}:`, error);
+        return null;
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function valueToAst(value) {
+    if (value === null)
+        return t.nullLiteral();
+    if (value === undefined)
+        return t.identifier('undefined');
+    if (typeof value === 'string')
+        return t.stringLiteral(value);
+    if (typeof value === 'number')
+        return t.numericLiteral(value);
+    if (typeof value === 'boolean')
+        return t.booleanLiteral(value);
+    return t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('parse')), [
+        t.stringLiteral(JSON.stringify(value)),
+    ]);
+}
+function getCalleeName(callee) {
+    if (t.isIdentifier(callee))
+        return callee.name;
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property))
+        return callee.property.name;
+    return null;
+}
+/**
+ * Check if an identifier matches an import condition
+ */
+function matchesImport(arg, parsed, state) {
+    if (!t.isIdentifier(arg))
+        return false;
+    const imported = state.imports.get(arg.name);
+    if (!imported)
+        return false;
+    return imported.importPath === parsed.importPath && imported.exportName === parsed.exportName;
+}
+// ============================================================================
+// Babel plugins
+// ============================================================================
+/**
+ * Collect all imports: localName -> { importPath, exportName }
+ */
+function collectImportsPlugin(state) {
+    return {
+        visitor: {
+            ImportDeclaration(path) {
+                const importPath = path.node.source.value;
+                for (const specifier of path.node.specifiers) {
+                    let exportName;
+                    if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported)) {
+                        exportName = specifier.imported.name;
+                    }
+                    else if (t.isImportDefaultSpecifier(specifier)) {
+                        exportName = 'default';
+                    }
+                    else {
+                        continue;
+                    }
+                    state.imports.set(specifier.local.name, { importPath, exportName });
+                }
+            },
+        },
+    };
+}
+/**
+ * Apply replacement rules to matching call expressions
+ */
+function applyRulesPlugin(state, rules) {
+    return {
+        visitor: {
+            CallExpression(path) {
+                const calleeName = getCalleeName(path.node.callee);
+                if (!calleeName)
+                    return;
+                for (const rule of rules) {
+                    if (!matchesRule(path, rule, calleeName, state))
+                        continue;
+                    if (rule.replace) {
+                        applyReplace(path, rule.replace, state);
+                    }
+                    else if (rule.remove) {
+                        applyRemove(path, rule.remove, state);
+                    }
+                }
+            },
+        },
+    };
+}
+/**
+ * Check if a call expression matches a rule
+ */
+function matchesRule(path, staticReplace, calleeName, state) {
+    const { match } = staticReplace;
+    // Check callee name
+    const functions = Array.isArray(match.function) ? match.function : [match.function];
+    if (!matchesCallee(path.node.callee, calleeName, functions, state))
+        return false;
+    // Check argument conditions
+    if (match.args) {
+        for (const [indexStr, condition] of Object.entries(match.args)) {
+            const index = Number(indexStr);
+            const arg = path.node.arguments[index];
+            if (!arg)
+                return false;
+            if (!matchesCondition(arg, condition, state))
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Check if callee matches any of the function patterns
+ */
+function matchesCallee(callee, calleeName, functions, state) {
+    for (const fn of functions) {
+        const parsed = parseImportString(fn);
+        if (parsed) {
+            // Import string: check if callee is an imported identifier
+            if (t.isIdentifier(callee)) {
+                const imported = state.imports.get(callee.name);
+                if (imported && imported.importPath === parsed.importPath && imported.exportName === parsed.exportName) {
+                    return true;
+                }
+            }
+            // Import string: check member expression
+            if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && t.isIdentifier(callee.property)) {
+                const imported = state.imports.get(callee.object.name);
+                if (imported &&
+                    imported.importPath === parsed.importPath &&
+                    imported.exportName === 'default' &&
+                    callee.property.name === parsed.exportName) {
+                    return true;
+                }
+            }
+        }
+        else {
+            // Plain string: match function name directly
+            if (calleeName === fn)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if an argument matches a condition
+ */
+function matchesCondition(arg, condition, state) {
+    // String condition
+    if (typeof condition === 'string') {
+        // Import condition: 'import:importPath:exportName'
+        const parsed = parseImportString(condition);
+        if (parsed) {
+            return t.isExpression(arg) && matchesImport(arg, parsed, state);
+        }
+        // Plain string: match string literal or identifier name
+        if (t.isStringLiteral(arg))
+            return arg.value === condition;
+        if (t.isIdentifier(arg))
+            return arg.name === condition;
+        return false;
+    }
+    // Call expression condition: match call with specific arguments
+    if ('call' in condition) {
+        if (!t.isCallExpression(arg))
+            return false;
+        const calleeName = getCalleeName(arg.callee);
+        if (!calleeName)
+            return false;
+        // Check if callee matches
+        const parsed = parseImportString(condition.call);
+        if (parsed) {
+            // Import string: check if callee is an imported identifier
+            if (!t.isIdentifier(arg.callee))
+                return false;
+            const imported = state.imports.get(arg.callee.name);
+            if (!imported || imported.importPath !== parsed.importPath || imported.exportName !== parsed.exportName) {
+                return false;
+            }
+        }
+        else {
+            // Plain string: match function name directly
+            if (calleeName !== condition.call)
+                return false;
+        }
+        // Check argument conditions
+        if (condition.args) {
+            for (const [indexStr, argCondition] of Object.entries(condition.args)) {
+                const index = Number(indexStr);
+                const nestedArg = arg.arguments[index];
+                if (!nestedArg)
+                    return false;
+                if (!matchesCondition(nestedArg, argCondition, state))
+                    return false;
+            }
+        }
+        return true;
+    }
+    // Member expression condition: match $setup["ClientOnly"]
+    if ('member' in condition) {
+        if (!t.isMemberExpression(arg))
+            return false;
+        // Check object
+        if (!t.isIdentifier(arg.object) || arg.object.name !== condition.object)
+            return false;
+        // Check property
+        if (typeof condition.property === 'string') {
+            // Simple string property
+            if (t.isIdentifier(arg.property) && !arg.computed) {
+                return arg.property.name === condition.property;
+            }
+            if (t.isStringLiteral(arg.property) && arg.computed) {
+                return arg.property.value === condition.property;
+            }
+            return false;
+        }
+        else {
+            // Nested condition on property (for future extensibility)
+            return false;
+        }
+    }
+    // Object condition: match prop value inside an object argument
+    if (!t.isObjectExpression(arg))
+        return false;
+    for (const prop of arg.properties) {
+        if (!t.isObjectProperty(prop))
+            continue;
+        if (!t.isIdentifier(prop.key) || prop.key.name !== condition.prop)
+            continue;
+        // Check value
+        if (condition.equals === null && t.isNullLiteral(prop.value))
+            return true;
+        if (condition.equals === true && t.isBooleanLiteral(prop.value) && prop.value.value === true)
+            return true;
+        if (condition.equals === false && t.isBooleanLiteral(prop.value) && prop.value.value === false)
+            return true;
+        if (typeof condition.equals === 'string' && t.isStringLiteral(prop.value) && prop.value.value === condition.equals)
+            return true;
+        if (typeof condition.equals === 'number' && t.isNumericLiteral(prop.value) && prop.value.value === condition.equals)
+            return true;
+    }
+    return false;
+}
+/**
+ * Apply a replacement to a call expression
+ */
+function applyReplace(path, replace, state) {
+    // Replace the entire call expression
+    if (!('arg' in replace) && !('argsFrom' in replace)) {
+        path.replaceWith(valueToAst(replace.with));
+        state.modified = true;
+        return;
+    }
+    // Replace a prop inside an object argument
+    if ('arg' in replace && 'prop' in replace) {
+        const arg = path.node.arguments[replace.arg];
+        if (!t.isObjectExpression(arg))
+            return;
+        for (const prop of arg.properties) {
+            if (!t.isObjectProperty(prop))
+                continue;
+            if (!t.isIdentifier(prop.key) || prop.key.name !== replace.prop)
+                continue;
+            prop.value = valueToAst(replace.with);
+            state.modified = true;
+            return;
+        }
+    }
+    // Replace entire argument
+    else if ('arg' in replace) {
+        if (path.node.arguments.length > replace.arg) {
+            path.node.arguments[replace.arg] = valueToAst(replace.with);
+            state.modified = true;
+        }
+    }
+    // Replace all args from index onwards with a single value
+    else if ('argsFrom' in replace) {
+        if (path.node.arguments.length > replace.argsFrom) {
+            path.node.arguments = [...path.node.arguments.slice(0, replace.argsFrom), valueToAst(replace.with)];
+            state.modified = true;
+        }
+    }
+}
+/**
+ * Apply a removal to a call expression
+ */
+function applyRemove(path, remove, state) {
+    // Remove a prop inside an object argument
+    if ('prop' in remove) {
+        const arg = path.node.arguments[remove.arg];
+        if (!t.isObjectExpression(arg))
+            return;
+        const index = arg.properties.findIndex((prop) => {
+            // Check ObjectProperty with Identifier key
+            if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === remove.prop) {
+                return true;
+            }
+            // Check ObjectMethod (getter/setter)
+            if (t.isObjectMethod(prop) && t.isIdentifier(prop.key) && prop.key.name === remove.prop) {
+                return true;
+            }
+            return false;
+        });
+        if (index !== -1) {
+            arg.properties.splice(index, 1);
+            state.modified = true;
+        }
+    }
+    // Remove entire argument
+    else if ('arg' in remove) {
+        if (path.node.arguments.length > remove.arg) {
+            path.node.arguments.splice(remove.arg, 1);
+            state.modified = true;
+        }
+    }
+    // Remove all args from index onwards
+    else if ('argsFrom' in remove) {
+        if (path.node.arguments.length > remove.argsFrom) {
+            path.node.arguments = path.node.arguments.slice(0, remove.argsFrom);
+            state.modified = true;
+        }
+    }
+}
+/**
+ * Remove unreferenced bindings after modifications
+ */
+function removeUnreferencedPlugin(state) {
+    return {
+        visitor: {
+            Program: {
+                enter(program) {
+                    for (const [name, binding] of Object.entries(program.scope.bindings)) {
+                        if (!binding.referenced)
+                            state.alreadyUnreferenced.add(name);
+                    }
+                },
+                exit(program) {
+                    if (!state.modified)
+                        return;
+                    removeUnreferenced(program, state.alreadyUnreferenced);
+                },
+            },
+        },
+    };
+}
+function removeUnreferenced(program, alreadyUnreferenced) {
+    for (;;) {
+        program.scope.crawl();
+        let removed = false;
+        for (const [name, binding] of Object.entries(program.scope.bindings)) {
+            if (binding.referenced || alreadyUnreferenced.has(name))
+                continue;
+            const parent = binding.path.parentPath;
+            if (parent?.isImportDeclaration() && parent.node.specifiers.length === 1) {
+                parent.remove();
+            }
+            else {
+                binding.path.remove();
+            }
+            removed = true;
+        }
+        if (!removed)
+            break;
+    }
+}

package/dist/node/vite/plugins/pluginStaticReplace/buildFilterRolldown.d.ts

@@ -0,0 +1,9 @@
+export { buildFilterRolldown };
+import type { StaticReplace } from './applyStaticReplace.js';
+/**
+ * Build a filterRolldown from staticReplaceList by extracting all import strings.
+ * For a single entry, ALL import strings must be present (AND logic),
+ * except for call.match.function array which is OR logic.
+ * Between staticReplace entries it's OR logic.
+ */
+declare function buildFilterRolldown(staticReplaceList: StaticReplace[]): RegExp | null;

package/dist/node/vite/plugins/pluginStaticReplace/buildFilterRolldown.js

@@ -0,0 +1,100 @@
+export { buildFilterRolldown };
+import { escapeRegex } from '../../utils.js';
+import { parseImportString } from '../../shared/importString.js';
+/**
+ * Build a filterRolldown from staticReplaceList by extracting all import strings.
+ * For a single entry, ALL import strings must be present (AND logic),
+ * except for call.match.function array which is OR logic.
+ * Between staticReplace entries it's OR logic.
+ */
+function buildFilterRolldown(staticReplaceList) {
+    const rulePatterns = [];
+    // Process each entry separately
+    for (const staticReplaceEntry of staticReplaceList) {
+        const importStrings = new Set();
+        const functionImportStrings = new Set();
+        // Extract function import strings separately
+        extractImportStrings(staticReplaceEntry.match.function, functionImportStrings);
+        // Extract arg import strings
+        if (staticReplaceEntry.match.args) {
+            for (const condition of Object.values(staticReplaceEntry.match.args)) {
+                extractImportStringsFromCondition(condition, importStrings);
+            }
+        }
+        // Build pattern for this staticReplaceEntry
+        const ruleParts = [];
+        // For function imports: if array, use OR; otherwise use AND
+        if (functionImportStrings.size > 0) {
+            const functionPatterns = [];
+            for (const importStr of functionImportStrings) {
+                const parts = parseImportString(importStr);
+                if (parts) {
+                    // Each function import should match both importPath and export name
+                    functionPatterns.push(`(?=.*${escapeRegex(parts.importPath)})(?=.*${escapeRegex(parts.exportName)})`);
+                }
+            }
+            // If multiple functions, they are alternatives (OR)
+            if (functionPatterns.length > 0) {
+                if (functionPatterns.length === 1) {
+                    ruleParts.push(functionPatterns[0]);
+                }
+                else {
+                    // Multiple function patterns: file must match at least one
+                    ruleParts.push(`(?:${functionPatterns.join('|')})`);
+                }
+            }
+        }
+        // For arg imports: all must be present (AND)
+        for (const importStr of importStrings) {
+            const parts = parseImportString(importStr);
+            if (parts) {
+                // Each arg import should match both importPath and export name
+                ruleParts.push(`(?=.*${escapeRegex(parts.importPath)})(?=.*${escapeRegex(parts.exportName)})`);
+            }
+        }
+        // Combine all parts for this rule with AND logic
+        if (ruleParts.length > 0) {
+            // All parts must match for this rule
+            rulePatterns.push(ruleParts.join(''));
+        }
+    }
+    if (rulePatterns.length === 0)
+        return null;
+    // Create a regex that matches if any rule pattern matches (OR between staticReplace entries)
+    return new RegExp(rulePatterns.join('|'), 's');
+}
+/**
+ * Extract import strings from function patterns
+ */
+function extractImportStrings(functions, result) {
+    const arr = Array.isArray(functions) ? functions : [functions];
+    for (const fn of arr) {
+        if (parseImportString(fn)) {
+            result.add(fn);
+        }
+    }
+}
+/**
+ * Extract import strings from argument conditions
+ */
+function extractImportStringsFromCondition(condition, result) {
+    if (typeof condition === 'string') {
+        if (parseImportString(condition)) {
+            result.add(condition);
+        }
+    }
+    else if (condition && typeof condition === 'object') {
+        // Handle call condition
+        if ('call' in condition && typeof condition.call === 'string') {
+            if (parseImportString(condition.call)) {
+                result.add(condition.call);
+            }
+            // Recursively check nested args
+            if (condition.args) {
+                for (const nestedCondition of Object.values(condition.args)) {
+                    extractImportStringsFromCondition(nestedCondition, result);
+                }
+            }
+        }
+    }
+}

package/dist/node/vite/plugins/pluginStaticReplace.d.ts

@@ -0,0 +1,4 @@
+export { pluginStaticReplace };
+import type { Plugin } from 'vite';
+import { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+declare function pluginStaticReplace(vikeConfig: VikeConfigInternal): Plugin[];

package/dist/node/vite/plugins/pluginStaticReplace.js

@@ -0,0 +1,71 @@
+export { pluginStaticReplace };
+import { assert } from '../utils.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { applyStaticReplace } from './pluginStaticReplace/applyStaticReplace.js';
+import { buildFilterRolldown } from './pluginStaticReplace/buildFilterRolldown.js';
+function pluginStaticReplace(vikeConfig) {
+    let config;
+    // staticReplaceList
+    const staticReplaceList = getStaticReplaceList(vikeConfig);
+    if (staticReplaceList.length === 0)
+        return [];
+    // filterRolldown
+    const skipNodeModules = '/node_modules/';
+    const include = buildFilterRolldown(staticReplaceList);
+    assert(include);
+    const filterRolldown = {
+        id: {
+            exclude: `**${skipNodeModules}**`,
+        },
+        code: {
+            include,
+        },
+    };
+    const filterFunction = (id, code) => {
+        if (id.includes(skipNodeModules))
+            return false;
+        if (!include.test(code))
+            return false;
+        return true;
+    };
+    return [
+        {
+            name: 'vike:pluginStaticReplace',
+            enforce: 'post',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                async handler(code, id, options) {
+                    assert(filterFunction(id, code));
+                    const env = isViteServerSide_extraSafe(config, this.environment, options) ? 'server' : 'client';
+                    const result = await applyStaticReplace({
+                        code,
+                        id,
+                        env,
+                        options: staticReplaceList,
+                    });
+                    return result;
+                },
+            },
+        },
+    ];
+}
+/**
+ * Extract all staticReplaceList from vikeConfig
+ */
+function getStaticReplaceList(vikeConfig) {
+    const staticReplaceConfigs = vikeConfig._from.configsCumulative.staticReplace;
+    if (!staticReplaceConfigs)
+        return [];
+    const staticReplaceList = [];
+    for (const configValue of staticReplaceConfigs.values) {
+        const entries = configValue.value;
+        assert(Array.isArray(entries));
+        staticReplaceList.push(...entries);
+    }
+    return staticReplaceList;
+}

package/dist/node/vite/plugins/pluginViteConfigVikeExtensions.d.ts

@@ -1,3 +1,4 @@
 export { pluginViteConfigVikeExtensions };
 import type { Plugin } from 'vite';
-declare function pluginViteConfigVikeExtensions(): Promise<Plugin[]>;
+import type { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+declare function pluginViteConfigVikeExtensions(vikeConfig: VikeConfigInternal): Promise<Plugin[]>;

package/dist/node/vite/plugins/pluginViteConfigVikeExtensions.js

@@ -1,11 +1,9 @@
 export { pluginViteConfigVikeExtensions };
 import { mergeConfig } from 'vite';
 import { assertUsage, isCallable, isObject } from '../utils.js';
-import { getVikeConfigInternalEarly } from '../../api/resolveViteConfigFromUser.js';
 // Apply +vite
 // - For example, Vike extensions adding Vite plugins
-async function pluginViteConfigVikeExtensions() {
-    const vikeConfig = await getVikeConfigInternalEarly();
+async function pluginViteConfigVikeExtensions(vikeConfig) {
     if (vikeConfig === null)
         return [];
     let viteConfigFromExtensions = {};

package/dist/node/vite/shared/importString.d.ts

@@ -0,0 +1,50 @@
+export { parseImportString };
+export { isImportString };
+export { serializeImportString };
+export type { ImportString };
+export type { ImportStringList };
+export type { ImportStringParsed };
+/** `import:${importPath}:${exportName}`
+ * @example import:./Layout:default
+ */
+type ImportString = `import:${string}:${string}`;
+type ImportStringList = ImportString | ImportString[];
+type ImportStringParsed = {
+    importPath: string;
+    exportName: string;
+};
+/**
+ * Parse import string in format: import:importPath:exportName
+ *
+ * @example parseImportString('import:react/jsx-runtime:jsx')
+ * // => { importPath: 'react/jsx-runtime', exportName: 'jsx' }
+ *
+ * @example parseImportString('import:./Layout:default')
+ * // => { importPath: './Layout', exportName: 'default' }
+ *
+ * @example parseImportString('import:./Layout', { legacy: true })
+ * // => { importPath: './Layout', exportName: 'default' }
+ */
+declare function parseImportString(importString: string, { legacy }?: {
+    legacy?: boolean;
+}): null | ImportStringParsed;
+/**
+ * Check if a string is an import string (starts with 'import:').
+ *
+ * @example isImportString('import:react:jsx')
+ * // => true
+ *
+ * @example isImportString('some-other-string')
+ * // => false
+ */
+declare function isImportString(str: string): str is ImportString;
+/**
+ * Serialize import string from importPath and export name.
+ *
+ * @example serializeImportString({ importPath: 'react/jsx-runtime', exportName: 'jsx' })
+ * // => 'import:react/jsx-runtime:jsx'
+ *
+ * @example serializeImportString({ importPath: './Layout', exportName: 'default' })
+ * // => 'import:./Layout:default'
+ */
+declare function serializeImportString({ importPath, exportName }: ImportStringParsed): `import:${string}:${string}`;

package/dist/node/vite/shared/importString.js

@@ -0,0 +1,64 @@
+export { parseImportString };
+export { isImportString };
+export { serializeImportString };
+import { assert } from '../utils.js';
+const IMPORT = 'import';
+const SEP = ':';
+/**
+ * Parse import string in format: import:importPath:exportName
+ *
+ * @example parseImportString('import:react/jsx-runtime:jsx')
+ * // => { importPath: 'react/jsx-runtime', exportName: 'jsx' }
+ *
+ * @example parseImportString('import:./Layout:default')
+ * // => { importPath: './Layout', exportName: 'default' }
+ *
+ * @example parseImportString('import:./Layout', { legacy: true })
+ * // => { importPath: './Layout', exportName: 'default' }
+ */
+function parseImportString(importString, { legacy = false } = {}) {
+    if (!isImportString(importString))
+        return null;
+    const parts = importString.split(SEP);
+    assert(parts[0] === IMPORT);
+    if (legacy && parts.length === 2) {
+        /* TODO
+        assertWarning(false, 'To-Do', { onlyOnce: true, showStackTrace: true })
+        */
+        const exportName = 'default';
+        const importPath = parts[1];
+        assert(importPath);
+        return { importPath, exportName };
+    }
+    assert(parts.length >= 3);
+    const exportName = parts[parts.length - 1];
+    const importPath = parts.slice(1, -1).join(SEP);
+    assert(exportName);
+    assert(importPath);
+    return { importPath, exportName };
+}
+/**
+ * Check if a string is an import string (starts with 'import:').
+ *
+ * @example isImportString('import:react:jsx')
+ * // => true
+ *
+ * @example isImportString('some-other-string')
+ * // => false
+ */
+function isImportString(str) {
+    return str.startsWith(`${IMPORT}${SEP}`);
+}
+/**
+ * Serialize import string from importPath and export name.
+ *
+ * @example serializeImportString({ importPath: 'react/jsx-runtime', exportName: 'jsx' })
+ * // => 'import:react/jsx-runtime:jsx'
+ *
+ * @example serializeImportString({ importPath: './Layout', exportName: 'default' })
+ * // => 'import:./Layout:default'
+ */
+function serializeImportString({ importPath, exportName }) {
+    const importString = `${IMPORT}${SEP}${importPath}${SEP}${exportName}`;
+    return importString;
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -270,6 +270,14 @@ const configDefinitionsBuiltIn = {
         env: { server: true },
         cumulative: true,
     },
+    staticReplace: {
+        env: { config: true },
+        cumulative: true,
+        global: true,
+        /* TODO
+        vite: true,
+        */
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

package/dist/node/vite/shared/resolveVikeConfigInternal/pointerImports.js

@@ -5,6 +5,7 @@ export { assertPointerImportPath };
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
 // - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
+// - Babel already supports it: https://babeljs.io/docs/babel-parser#plugins => search for `importAttributes`
 // - Acorn support for import attributes: https://github.com/acornjs/acorn/issues/983
 //   - Acorn plugin: https://github.com/acornjs/acorn/issues/983
 //   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
@@ -17,9 +18,10 @@ export { assertPointerImportPath };
 // - Using a magic comment `// @vike-real-import` is probably a bad idea:
 //   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
 //   - Using source maps to track these magic comments is brittle (source maps can easily break)
-import { parse } from 'acorn';
+import { parseSync } from '@babel/core';
 import { assert, assertUsage, assertWarning, isFilePathAbsolute, isImportPath, styleFileRE } from '../../utils.js';
 import pc from '@brillout/picocolors';
+import { parseImportString, isImportString, serializeImportString } from '../importString.js';
 function transformPointerImports(code, filePathToShowToUser2, pointerImports, 
 // For ./transformPointerImports.spec.ts
 skipWarnings) {
@@ -103,11 +105,11 @@ skipWarnings) {
     return codeMod;
 }
 function getImports(code) {
-    const { body } = parse(code, {
-        ecmaVersion: 'latest',
+    const result = parseSync(code, {
         sourceType: 'module',
-        // https://github.com/acornjs/acorn/issues/1136
     });
+    assert(result);
+    const { body } = result.program;
     const imports = [];
     body.forEach((node) => {
         if (node.type === 'ImportDeclaration')
@@ -115,16 +117,13 @@ function getImports(code) {
     });
     return imports;
 }
-const import_ = 'import';
-const SEP = ':';
 const zeroWidthSpace = '\u200b';
 function serializePointerImportData({ importPath, exportName, importStringWasGenerated, }) {
     const tag = importStringWasGenerated ? zeroWidthSpace : '';
-    // `import:${importPath}:${importPath}`
-    return `${tag}${import_}${SEP}${importPath}${SEP}${exportName}`;
+    return `${tag}${serializeImportString({ importPath, exportName })}`;
 }
 function isPointerImportData(str) {
-    return str.startsWith(import_ + SEP) || str.startsWith(zeroWidthSpace + import_ + SEP);
+    return isImportString(str) || (str.startsWith(zeroWidthSpace) && isImportString(str.slice(1)));
 }
 function parsePointerImportData(importString) {
     if (!isPointerImportData(importString)) {
@@ -136,15 +135,9 @@ function parsePointerImportData(importString) {
         assert(zeroWidthSpace.length === 1);
         importString = importString.slice(1);
     }
-    const parts = importString.split(SEP).slice(1);
-    if (!importStringWasGenerated && parts.length === 1) {
-        const exportName = 'default';
-        const importPath = parts[0];
-        return { importPath, exportName, importStringWasGenerated, importString };
-    }
-    assert(parts.length >= 2);
-    const exportName = parts[parts.length - 1];
-    const importPath = parts.slice(0, -1).join(SEP);
+    const parsed = parseImportString(importString, { legacy: !importStringWasGenerated });
+    assert(parsed);
+    const { importPath, exportName } = parsed;
     if (importPath.startsWith('.') && !(importPath.startsWith('./') || importPath.startsWith('../'))) {
         assert(!importStringWasGenerated);
         assertUsage(false, `Invalid relative import path ${pc.code(importPath)} defined by ${pc.code(JSON.stringify(importString))} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);

package/dist/server/runtime/renderPageServer/csp.js

@@ -32,6 +32,7 @@ async function generateNonce() {
     return cryptoModule.randomBytes(16).toString('base64url');
 }
 function inferNonceAttr(pageContext) {
+    // No need to escape the injected HTML — pageContext.cspNone is controlled by the developer, not by the website visitor (I wouldn't know why the developer would set +csp.none to a value coming from the database)
     const nonceAttr = pageContext.cspNonce ? ` nonce="${pageContext.cspNonce}"` : '';
     return nonceAttr;
 }
@@ -41,5 +42,6 @@ function addCspResponseHeader(pageContext, headersResponse) {
         return;
     if (headersResponse.get('Content-Security-Policy'))
         return;
+    // No need to sanitize the injected header — see comment above about not escaping HTML
     headersResponse.set('Content-Security-Policy', `script-src 'self' 'nonce-${pageContext.cspNonce}'`);
 }

package/dist/types/Config/ConfigResolved.d.ts

@@ -1,8 +1,9 @@
 export type { ConfigResolved };
-import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
+import type { ConfigBuiltIn, ConfigBuiltInResolved } from '../Config.js';
+import type { ImportStringList } from '../../node/vite/shared/importString.js';
 type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
 type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
 type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
 type WithoutImportString<T> = {
-    [K in keyof T]: Exclude<T[K], ImportString>;
+    [K in keyof T]: Exclude<T[K], ImportStringList>;
 };

package/dist/types/Config.d.ts

@@ -8,7 +8,6 @@ export type { HookName };
 export type { HookNameOld };
 export type { HookNamePage };
 export type { HookNameGlobal };
-export type { ImportString };
 export type { Route };
 export type { KeepScrollPosition };
 export type { DataAsync };
@@ -47,6 +46,8 @@ import type { GlobalContext } from './GlobalContext.js';
 import type { InlineConfig } from 'vite';
 import type { PassToClientPublic } from '../server/runtime/renderPageServer/html/serializeContext.js';
 import type { CliPreviewConfig } from '../node/api/preview.js';
+import type { StaticReplace } from '../node/vite/plugins/pluginStaticReplace/applyStaticReplace.js';
+import type { ImportStringList } from '../node/vite/shared/importString.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
@@ -250,12 +251,12 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: Route | ImportString;
+    route?: Route | ImportStringList;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard
      */
-    guard?: GuardAsync | GuardSync | ImportString;
+    guard?: GuardAsync | GuardSync | ImportStringList;
     /**
      * Pre-render page(s).
      *
@@ -264,7 +265,7 @@ type ConfigBuiltIn = {
      *
      * @default false
      */
-    prerender?: boolean | ImportString | {
+    prerender?: boolean | ImportStringList | {
         /**
          * Allow only some of your pages to be pre-rendered.
          *
@@ -339,32 +340,32 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/extends
      */
-    extends?: Config | Config[] | ImportString;
+    extends?: Config | Config[] | ImportStringList;
     /** Hook called before the page is rendered.
      *
      *  https://vike.dev/onBeforeRender
      */
-    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
+    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportStringList | null;
     /** Hook called when a `pageContext` object is created.
      *
      *  https://vike.dev/onCreatePageContext
      */
-    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportString | null;
+    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportStringList | null;
     /** Hook called when an error occurs during server-side rendering.
      *
      *  https://vike.dev/onError
      */
-    onError?: ((error: unknown, pageContext: null | PageContextServer) => void) | ImportString | null;
+    onError?: ((error: unknown, pageContext: null | PageContextServer) => void) | ImportStringList | null;
     /** Hook called when the `globalContext` object is created.
      *
      *  https://vike.dev/onCreateGlobalContext
      */
-    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportString | null;
+    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportStringList | null;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data
      */
-    data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
+    data?: DataAsync<unknown> | DataSync<unknown> | ImportStringList | null;
     /** Hook called as soon as `pageContext.data` is available.
      *
      *  https://vike.dev/onData
@@ -374,83 +375,83 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/passToClient
      */
-    passToClient?: PassToClientPublic | ImportString;
+    passToClient?: PassToClientPublic | ImportStringList;
     /** Hook called when page is rendered on the client-side.
      *
      * https://vike.dev/onRenderClient
      */
-    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportString;
+    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportStringList;
     /** Hook called when page is rendered to HTML on the server-side.
      *
      * https://vike.dev/onRenderHtml
      */
-    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportString;
+    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportStringList;
     /** Enable async Route Functions.
      *
      * https://vike.dev/route-function#async
      */
-    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportString;
+    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportStringList;
     /** Change the URL root of Filesystem Routing.
      *
      * https://vike.dev/filesystemRoutingRoot
      */
-    filesystemRoutingRoot?: string | ImportString;
+    filesystemRoutingRoot?: string | ImportStringList;
     /** Page Hook called when pre-rendering starts.
      *
      * https://vike.dev/onPrerenderStart
      */
-    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportString;
+    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportStringList;
     /** Global Hook called before the whole pre-rendering process starts.
      *
      * https://vike.dev/onBeforePrerenderStart
      */
-    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportString;
+    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportStringList;
     /** Hook called before the URL is routed to a page.
      *
      * https://vike.dev/onBeforeRoute
      */
-    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
+    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportStringList;
     /** Hook called after the page is hydrated.
      *
      * https://vike.dev/onHydrationEnd
      */
-    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
+    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportStringList;
     /** Hook called before the user navigates to a new page.
      *
      * https://vike.dev/onPageTransitionStart
      */
-    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
+    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportStringList;
     /** Hook called after the user navigates to a new page.
      *
      * https://vike.dev/onPageTransitionEnd
      */
-    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
+    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportStringList;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
      * https://vike.dev/hydrationCanBeAborted
      */
-    hydrationCanBeAborted?: boolean | ImportString;
+    hydrationCanBeAborted?: boolean | ImportStringList;
     /** Add client code.
      *
      * https://vike.dev/client
      */
-    client?: string | ImportString;
+    client?: string | ImportStringList;
     /** Enable Client Routing.
      *
      * https://vike.dev/clientRouting
      */
-    clientRouting?: boolean | ImportString;
+    clientRouting?: boolean | ImportStringList;
     /**
      * Whether hooks are loaded on the client-side.
      *
      * https://vike.dev/clientHooks
      */
-    clientHooks?: boolean | null | ImportString;
+    clientHooks?: boolean | null | ImportStringList;
     /** Create new or modify existing configurations.
      *
      * https://vike.dev/meta
      */
-    meta?: ConfigMeta | ImportString;
+    meta?: ConfigMeta | ImportStringList;
     /** Vite configuration.
      *
      * https://vite.dev/config/
@@ -498,13 +499,13 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/prefetch
      */
-    prefetch?: PrefetchSetting | ImportString;
+    prefetch?: PrefetchSetting | ImportStringList;
     /** @deprecated Use `prefetch` setting (https://vike.dev/prefetch) instead.  */
     /** Prefetch links.
      *
      * https://vike.dev/prefetchStaticAssets
      */
-    prefetchStaticAssets?: PrefetchStaticAssets | ImportString;
+    prefetchStaticAssets?: PrefetchStaticAssets | ImportStringList;
     /** Modify the timeouts of hooks. */
     hooksTimeout?: HooksTimeoutProvidedByUser;
     /** `Cache-Control` HTTP header value.
@@ -587,14 +588,19 @@ type ConfigBuiltIn = {
     cli?: {
         preview?: CliPreviewConfig;
     };
+    /**
+     * Static code transformations for optimizations like removing component children server-side.
+     *
+     * @experimental
+     */
+    staticReplace?: StaticReplace[];
 };
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];
-    prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
+    prerender?: Exclude<Config['prerender'], ImportStringList | undefined>[];
     middleware?: Function[];
-    headersResponse?: Exclude<Config['headersResponse'], ImportString | undefined>[];
+    headersResponse?: Exclude<Config['headersResponse'], ImportStringList | undefined>[];
+    staticReplace?: StaticReplace[][];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
-type ImportString = ImportStringVal | ImportStringVal[];
-type ImportStringVal = `import:${string}`;

package/dist/types/index.d.ts

@@ -4,7 +4,8 @@ export type { PrerenderContextPublic as PrerenderContext } from '../node/prerend
 export type { PageContextBuiltInServer } from './PageContext.js';
 export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';
 export type { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
-export type { Config, ConfigMeta as Meta, ImportString, KeepScrollPosition, } from './Config.js';
+export type { Config, ConfigMeta as Meta, KeepScrollPosition, } from './Config.js';
+export type { ImportString } from '../node/vite/shared/importString.js';
 export type { DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, } from './Config.js';
 export type { ConfigResolved } from './Config/ConfigResolved.js';
 export type { ConfigEnv } from './PageConfig.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.249-commit-f416149";
+export declare const PROJECT_VERSION: "0.4.249-commit-92f1383";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.249-commit-f416149';
+export const PROJECT_VERSION = '0.4.249-commit-92f1383';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.249-commit-f416149",
+  "version": "0.4.249-commit-92f1383",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -118,12 +118,12 @@
     }
   },
   "dependencies": {
+    "@babel/core": "^7.28.5",
     "@brillout/import": "^0.2.6",
     "@brillout/json-serializer": "^0.5.21",
     "@brillout/picocolors": "^1.0.30",
     "@brillout/require-shim": "^0.1.2",
     "@brillout/vite-plugin-server-entry": "^0.7.15",
-    "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
     "esbuild": ">=0.19.0",
@@ -244,7 +244,9 @@
     "./universal-middleware.js"
   ],
   "devDependencies": {
+    "@babel/types": "^7.28.5",
     "@brillout/release-me": "^0.4.12",
+    "@types/babel__core": "^7.20.5",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.10.5",
     "@types/picomatch": "^3.0.2",