vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/cjs/node/prerender/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/projectInfo.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/isObjectWithKeys.js"), exports);
+__exportStar(require("../../utils/isCallable.js"), exports);
+__exportStar(require("../../utils/getOutDirs.js"), exports);
+__exportStar(require("../../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../../utils/urlToFile.js"), exports);
+__exportStar(require("../../shared/hooks/executeHook.js"), exports);
+__exportStar(require("../../utils/isPlainObject.js"), exports);
+__exportStar(require("../../utils/nodeEnv.js"), exports);

package/dist/cjs/node/runtime/globalContext/loadImportBuild.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setImportBuildGetters = exports.loadImportBuild = void 0;
+const loadServerBuild_js_1 = require("@brillout/vite-plugin-import-build/loadServerBuild.js");
+const utils_js_1 = require("../utils.js");
+const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
+    getters: null
+});
+function setImportBuildGetters(getters) {
+    buildGetters.getters = getters;
+}
+exports.setImportBuildGetters = setImportBuildGetters;
+async function loadImportBuild(outDir) {
+    if (!buildGetters.getters) {
+        await (0, loadServerBuild_js_1.loadServerBuild)(outDir);
+        // Await dist/server/importBuild.cjs
+        await (0, utils_js_1.autoRetry)(() => {
+            (0, utils_js_1.assert)(buildGetters.getters);
+        }, 2000);
+        (0, utils_js_1.assert)(buildGetters.getters);
+    }
+    const [pageFiles, clientManifest, pluginManifest] = await Promise.all([
+        buildGetters.getters.pageFiles(),
+        buildGetters.getters.clientManifest(),
+        buildGetters.getters.pluginManifest()
+    ]);
+    const buildEntries = { pageFiles, clientManifest, pluginManifest };
+    return buildEntries;
+}
+exports.loadImportBuild = loadImportBuild;

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

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRuntimeManifest = exports.setGlobalContext_viteConfig = exports.setGlobalContext_vitePreviewServer = exports.setGlobalContext_viteDevServer = exports.getViteConfig = exports.getViteDevServer = exports.getGlobalContext = exports.initGlobalContext = void 0;
+const utils_js_1 = require("./utils.js");
+const loadImportBuild_js_1 = require("./globalContext/loadImportBuild.js");
+const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
+const assertPluginManifest_js_1 = require("../shared/assertPluginManifest.js");
+const getConfigVike_js_1 = require("../shared/getConfigVike.js");
+const assertRuntimeManifest_js_1 = require("../shared/assertRuntimeManifest.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', {});
+function getGlobalContext() {
+    (0, utils_js_1.assert)(globalObject.globalContext);
+    return globalObject.globalContext;
+}
+exports.getGlobalContext = getGlobalContext;
+function setGlobalContext_viteDevServer(viteDevServer) {
+    if (globalObject.viteDevServer)
+        return;
+    (0, utils_js_1.assert)(!globalObject.globalContext);
+    globalObject.viteDevServer = viteDevServer;
+}
+exports.setGlobalContext_viteDevServer = setGlobalContext_viteDevServer;
+function setGlobalContext_vitePreviewServer(vitePreviewServer) {
+    if (globalObject.vitePreviewServer)
+        return;
+    (0, utils_js_1.assert)(!globalObject.globalContext);
+    globalObject.vitePreviewServer = vitePreviewServer;
+}
+exports.setGlobalContext_vitePreviewServer = setGlobalContext_vitePreviewServer;
+function getViteDevServer() {
+    return globalObject.viteDevServer ?? null;
+}
+exports.getViteDevServer = getViteDevServer;
+function setGlobalContext_viteConfig(viteConfig) {
+    if (globalObject.viteConfig)
+        return;
+    (0, utils_js_1.assert)(!globalObject.globalContext);
+    globalObject.viteConfig = viteConfig;
+}
+exports.setGlobalContext_viteConfig = setGlobalContext_viteConfig;
+function getViteConfig() {
+    return globalObject.viteConfig ?? null;
+}
+exports.getViteConfig = getViteConfig;
+async function initGlobalContext(isPrerendering = false, outDir) {
+    if (globalObject.globalContext)
+        return;
+    const { viteDevServer, vitePreviewServer, viteConfig } = globalObject;
+    assertNodeEnv(!!viteDevServer);
+    const isProduction = !viteDevServer;
+    if (!isProduction) {
+        (0, utils_js_1.assert)(viteConfig);
+        (0, utils_js_1.assert)(!isPrerendering);
+        (0, utils_js_1.assert)(!vitePreviewServer);
+        const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
+        const pluginManifest = getRuntimeManifest(configVike);
+        globalObject.globalContext = {
+            isProduction: false,
+            isPrerendering: false,
+            clientManifest: null,
+            pluginManifest: null,
+            viteDevServer,
+            vitePreviewServer: null,
+            viteConfig,
+            configVike,
+            baseServer: pluginManifest.baseServer,
+            baseAssets: pluginManifest.baseAssets,
+            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
+            redirects: pluginManifest.redirects,
+            trailingSlash: pluginManifest.trailingSlash,
+            disableUrlNormalization: pluginManifest.disableUrlNormalization
+        };
+    }
+    else {
+        const buildEntries = await (0, loadImportBuild_js_1.loadImportBuild)(outDir);
+        assertBuildEntries(buildEntries, isPrerendering ?? false);
+        const { pageFiles, clientManifest, pluginManifest } = buildEntries;
+        (0, getPageFiles_js_1.setPageFiles)(pageFiles);
+        assertViteManifest(clientManifest);
+        (0, assertPluginManifest_js_1.assertPluginManifest)(pluginManifest);
+        const globalContext = {
+            isProduction: true,
+            clientManifest,
+            pluginManifest,
+            viteDevServer: null,
+            vitePreviewServer: vitePreviewServer ?? null,
+            baseServer: pluginManifest.baseServer,
+            baseAssets: pluginManifest.baseAssets,
+            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
+            redirects: pluginManifest.redirects,
+            trailingSlash: pluginManifest.trailingSlash,
+            disableUrlNormalization: pluginManifest.disableUrlNormalization
+        };
+        if (isPrerendering) {
+            (0, utils_js_1.assert)(viteConfig);
+            const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
+            (0, utils_js_1.assert)(configVike);
+            (0, utils_js_1.objectAssign)(globalContext, {
+                isPrerendering: true,
+                viteConfig,
+                configVike
+            });
+            globalObject.globalContext = globalContext;
+        }
+        else {
+            (0, utils_js_1.objectAssign)(globalContext, {
+                isPrerendering: false,
+                viteConfig: null,
+                configVike: null
+            });
+            globalObject.globalContext = globalContext;
+        }
+    }
+}
+exports.initGlobalContext = initGlobalContext;
+function getRuntimeManifest(configVike) {
+    const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;
+    const manifest = {
+        baseServer,
+        baseAssets,
+        includeAssetsImportedByServer,
+        redirects,
+        trailingSlash,
+        disableUrlNormalization
+    };
+    (0, assertRuntimeManifest_js_1.assertRuntimeManifest)(manifest);
+    return manifest;
+}
+exports.getRuntimeManifest = getRuntimeManifest;
+function assertBuildEntries(buildEntries, isPreRendering) {
+    const errMsg = [
+        `You are tyring to run`,
+        isPreRendering ? 'pre-rendering' : 'the server for production',
+        `but your app isn't built yet. Run ${picocolors_1.default.cyan('$ vite build')} before `,
+        isPreRendering ? 'pre-rendering.' : 'running the server.'
+    ].join(' ');
+    (0, utils_js_1.assertUsage)(buildEntries, errMsg);
+}
+function assertViteManifest(manifest) {
+    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(manifest));
+    /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
+       Instead, we should rename the vite manifest e.g. with https://vitejs.dev/config/build-options.html#build-manifest
+    Object.entries(manifest)
+      // circumvent esbuild bug: esbuild adds a `default` key to JSON upon `require('./some.json')`.
+      .filter(([key]) => key !== 'default')
+      .forEach(([_, entry]) => {
+        assert(isPlainObject(entry))
+        assert(typeof entry.file === 'string')
+      })
+    */
+}
+function assertNodeEnv(hasViteDevServer) {
+    const nodeEnv = (0, utils_js_1.getNodeEnv)();
+    if (nodeEnv === null || nodeEnv === 'test')
+        return;
+    const isDevNodeEnv = [undefined, '', 'dev', 'development'].includes(nodeEnv);
+    // calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    (0, utils_js_1.assertWarning)(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${picocolors_1.default.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+}

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHtmlTags = void 0;
+const utils_js_1 = require("../../utils.js");
+const serializePageContextClientSide_js_1 = require("../serializePageContextClientSide.js");
+const sanitizeJson_js_1 = require("./sanitizeJson.js");
+const inferHtmlTags_js_1 = require("./inferHtmlTags.js");
+const getViteDevScripts_js_1 = require("./getViteDevScripts.js");
+const mergeScriptTags_js_1 = require("./mergeScriptTags.js");
+const globalContext_js_1 = require("../../globalContext.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function getHtmlTags(pageContext, injectToStream, injectFilter) {
+    (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
+    const isHtmlOnly = pageContext._isHtmlOnly;
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const { isProduction } = globalContext;
+    const injectJavaScriptDuringStream = !pageContext._pageContextPromise && !!injectToStream;
+    const pageAssets = await pageContext.__getPageAssets();
+    const stamp = Symbol('injectFilterEntryStamp');
+    const getInject = (asset) => {
+        if (!isProduction) {
+            return 'HTML_BEGIN';
+        }
+        if (asset.assetType === 'style' || asset.assetType === 'font') {
+            return 'HTML_BEGIN';
+        }
+        if (asset.assetType === 'script') {
+            return 'HTML_END';
+        }
+        return false;
+    };
+    const injectFilterEntries = pageAssets
+        .filter((asset) => {
+        if (asset.isEntry && asset.assetType === 'script') {
+            // We could in principle allow the user to change the position of <script> but we don't because of `getMergedScriptTag()`
+            return false;
+        }
+        if (isHtmlOnly && asset.assetType === 'script') {
+            return false;
+        }
+        return true;
+    })
+        .map((asset) => {
+        const inject = getInject(asset);
+        const entry = {
+            ...asset,
+            inject,
+            // @ts-ignore
+            [stamp]: true
+        };
+        return entry;
+    });
+    assertInjectFilterEntries(injectFilterEntries, stamp);
+    if (injectFilter && isProduction) {
+        Object.seal(injectFilterEntries); // `Object.seal()` instead of `Object.freeze()` to allow the user to `assets.sort()`
+        Object.values(injectFilterEntries).forEach((entry) => (0, utils_js_1.freezePartial)(entry, { inject: (val) => val === false || val === 'HTML_BEGIN' || val === 'HTML_END' }));
+        const res = injectFilter(injectFilterEntries);
+        (0, utils_js_1.assertUsage)(res === undefined, 'Wrong injectFilter() usage, see https://vike.dev/injectFilter');
+        assertInjectFilterUsage(injectFilterEntries, stamp);
+        injectFilterEntries.forEach((a) => {
+            /*
+            if (a.assetType === 'script' && a.isEntry) {
+              assertUsage(a.inject, `[injectFilter()] ${a.src} needs to be injected`)
+            }
+            */
+            if (a.assetType === 'style' && a.isEntry) {
+                // In development, Vite automatically inject styles, but we still inject `<link rel="stylesheet" type="text/css" href="${src}">` tags in order to avoid FOUC (flash of unstyled content).
+                //  - https://github.com/vitejs/vite/issues/2282
+                //  - https://github.com/vikejs/vike/issues/261
+                (0, utils_js_1.assertWarning)(a.inject, `[injectFilter()] We recommend against not injecting ${a.src}`, {
+                    onlyOnce: true
+                });
+            }
+            if (!isHtmlOnly && a.assetType === 'script') {
+                (0, utils_js_1.assertWarning)(a.inject, `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`, {
+                    onlyOnce: true
+                });
+            }
+        });
+    }
+    const htmlTags = [];
+    // Non-JavaScript
+    for (const asset of injectFilterEntries) {
+        if (asset.assetType !== 'script' && asset.inject) {
+            const htmlTag = asset.isEntry ? (0, inferHtmlTags_js_1.inferAssetTag)(asset) : (0, inferHtmlTags_js_1.inferPreloadTag)(asset);
+            htmlTags.push({ htmlTag, position: asset.inject });
+        }
+    }
+    // JavaScript
+    const positionProd = injectJavaScriptDuringStream ? 'STREAM' : 'HTML_END';
+    const positionScript = !isProduction ? 'HTML_BEGIN' : positionProd;
+    const positionJsonData = !isProduction && !pageContext._pageContextPromise && !pageContext._isStream ? 'HTML_BEGIN' : positionProd;
+    const jsScript = await getMergedScriptTag(pageAssets, isProduction);
+    if (jsScript) {
+        htmlTags.push({
+            htmlTag: jsScript,
+            position: positionScript
+        });
+    }
+    for (const asset of injectFilterEntries) {
+        if (asset.assetType === 'script' && asset.inject) {
+            const htmlTag = asset.isEntry ? (0, inferHtmlTags_js_1.inferAssetTag)(asset) : (0, inferHtmlTags_js_1.inferPreloadTag)(asset);
+            const position = asset.inject === 'HTML_END' ? positionScript : asset.inject;
+            htmlTags.push({ htmlTag, position });
+        }
+    }
+    // `pageContext` JSON data
+    if (!isHtmlOnly) {
+        // Don't allow the user to manipulate with injectFilter(): injecting <script type="application/json"> before the stream can break the app when:
+        //  - using https://vike.dev/stream#initial-data-after-stream-end
+        //  - `pageContext` is modified during the stream, e.g. /examples/vue-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
+        // The <script> tags are handled separately by vike down below.
+        htmlTags.push({
+            // Needs to be called after `resolvePageContextPromise()`
+            htmlTag: () => getPageContextTag(pageContext),
+            position: positionJsonData
+        });
+    }
+    return htmlTags;
+}
+exports.getHtmlTags = getHtmlTags;
+async function getMergedScriptTag(pageAssets, isProduction) {
+    const scriptAssets = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
+    const viteScripts = await (0, getViteDevScripts_js_1.getViteDevScripts)();
+    const scriptTagsHtml = `${viteScripts}${scriptAssets.map((asset) => (0, inferHtmlTags_js_1.inferAssetTag)(asset)).join('')}`;
+    const scriptTag = (0, mergeScriptTags_js_1.mergeScriptTags)(scriptTagsHtml, isProduction);
+    return scriptTag;
+}
+function getPageContextTag(pageContext) {
+    const pageContextSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext));
+    const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    // @ts-expect-error
+    pageContext._pageContextHtmlTag = htmlTag;
+    return htmlTag;
+}
+function assertInjectFilterEntries(injectFilterEntries, stamp) {
+    try {
+        assertInjectFilterUsage(injectFilterEntries, stamp);
+    }
+    catch (err) {
+        if (err?.message.includes('[Wrong Usage]')) {
+            (0, utils_js_1.assert)(false);
+        }
+        throw err;
+    }
+}
+function assertInjectFilterUsage(injectFilterEntries, stamp) {
+    injectFilterEntries.forEach((entry, i) => {
+        (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(entry), `[injectFilter()] Entry ${i} isn't an object`);
+        (0, utils_js_1.assertUsage)(typeof entry.src === 'string', `[injectFilter()] Entry ${i} is missing property ${picocolors_1.default.cyan('src')}`);
+        (0, utils_js_1.assertUsage)(entry[stamp] === true, `[injectFilter()] Entry ${i} (${entry.src}) isn't the original object, see https://vike.dev/injectFilter`);
+        (0, utils_js_1.assert)([false, 'HTML_BEGIN', 'HTML_END'].includes(entry.inject));
+        (0, utils_js_1.assert)(entry.assetType === null || typeof entry.assetType === 'string');
+        (0, utils_js_1.assert)(entry.mediaType === null || typeof entry.mediaType === 'string');
+        (0, utils_js_1.assert)(typeof entry.isEntry === 'boolean');
+        (0, utils_js_1.assert)(Object.keys(entry).length === 5);
+    });
+}

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScripts.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getViteDevScripts = void 0;
+const globalContext_js_1 = require("../../globalContext.js");
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function getViteDevScripts() {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    if (globalContext.isProduction) {
+        return '';
+    }
+    const { viteDevServer } = globalContext;
+    const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
+    const fakeHtmlEnd = '</head><body></body></html>';
+    let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
+    fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
+    (0, utils_js_1.assertUsage)(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${picocolors_1.default.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
+    (0, utils_js_1.assertUsage)(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), 'Vite plugins that minify the HTML are not supported by vike, see https://github.com/vikejs/vike/issues/224');
+    (0, utils_js_1.assertUsage)(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), 'You are using a Vite Plugin that transforms the HTML in a way that conflicts with vike. Create a new GitHub ticket to discuss a solution.');
+    const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
+    (0, utils_js_1.assert)(viteInjection.includes('script'), { viteInjection });
+    const scriptTags = viteInjection;
+    return scriptTags;
+}
+exports.getViteDevScripts = getViteDevScripts;

package/dist/cjs/node/runtime/html/injectAssets/inferHtmlTags.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferEarlyHintLink = exports.inferPreloadTag = exports.inferAssetTag = void 0;
+const utils_js_1 = require("../../utils.js");
+function inferPreloadTag(pageAsset) {
+    const { src, assetType, mediaType } = pageAsset;
+    const rel = getRel(pageAsset);
+    const attributes = [
+        `rel="${rel}"`,
+        `href="${src}"`,
+        !assetType ? null : `as="${assetType}"`,
+        !mediaType ? null : `type="${mediaType}"`,
+        // `crossorigin` is needed for fonts, see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#cors-enabled_fetches
+        !isCrossOrigin(pageAsset) ? null : 'crossorigin'
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return `<link ${attributes}>`;
+}
+exports.inferPreloadTag = inferPreloadTag;
+function inferAssetTag(pageAsset) {
+    const { src, assetType, mediaType } = pageAsset;
+    if (assetType === 'script') {
+        (0, utils_js_1.assert)(mediaType === 'text/javascript');
+        // Using <script async> seems problematic:
+        //  - in dev: https://github.com/vikejs/vike/issues/524
+        //  - in prod: https://github.com/vikejs/vike/issues/567
+        return `<script type="module" src="${src}" defer></script>`;
+    }
+    if (assetType === 'style') {
+        return `<link rel="stylesheet" type="text/css" href="${src}">`;
+    }
+    (0, utils_js_1.assert)(false, { pageAsset });
+}
+exports.inferAssetTag = inferAssetTag;
+// We ignore crossorigin, it seems like Early Hints doesn't have a "crossorigin" property: https://github.com/vikejs/vike/issues/618#issuecomment-1415752222
+function inferEarlyHintLink(pageAsset) {
+    const { src, assetType } = pageAsset;
+    const rel = getRel(pageAsset);
+    return [`<${src}>`, `rel=${rel}`, !assetType ? null : `as=${assetType}`].filter(Boolean).join('; ');
+}
+exports.inferEarlyHintLink = inferEarlyHintLink;
+function getRel({ assetType }) {
+    if (assetType === 'script') {
+        // Vite transpiles all browser-side JavaScript to ESM
+        return 'modulepreload';
+    }
+    return 'preload';
+}
+function isCrossOrigin({ src, assetType }) {
+    return assetType === 'font' || src.startsWith('http://') || src.startsWith('https://');
+}

package/dist/cjs/node/runtime/html/injectAssets/injectAssets__public.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectAssets__public = void 0;
+const utils_js_1 = require("../../utils.js");
+const injectAssets_js_1 = require("../injectAssets.js");
+// TODO: remove this on next semver major
+async function injectAssets__public(htmlString, pageContext) {
+    (0, utils_js_1.assertWarning)(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
+    (0, utils_js_1.assertUsage)(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });
+    (0, utils_js_1.assertUsage)(pageContext, '[injectAssets(htmlString, pageContext)]: Argument `pageContext` is missing.', {
+        showStackTrace: true
+    });
+    const errMsg = (body) => '[injectAssets(htmlString, pageContext)]: ' +
+        body +
+        '. Make sure that `pageContext` is the object that Vike provided to your `render(pageContext)` hook.';
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
+        showStackTrace: true
+    });
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'), errMsg('`pageContext._pageId` should be a string'), {
+        showStackTrace: true
+    });
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {
+        showStackTrace: true
+    });
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContext, '_passToClient', 'string[]'), errMsg('`pageContext._passToClient` is missing'), {
+        showStackTrace: true
+    });
+    (0, utils_js_1.castProp)(pageContext, '__getPageAssets');
+    htmlString = await (0, injectAssets_js_1.injectHtmlTagsToString)([htmlString], pageContext, null);
+    return htmlString;
+}
+exports.injectAssets__public = injectAssets__public;

package/dist/cjs/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -0,0 +1,157 @@
+"use strict";
+// Unit tests at ./injectHtmlTags.spec.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectAtClosingTag = exports.injectAtOpeningTag = exports.createHtmlHeadIfMissing = exports.injectHtmlTags = void 0;
+const utils_js_1 = require("../../utils.js");
+const POSITIONS = ['HTML_BEGIN', 'HTML_END', 'STREAM'];
+function injectHtmlTags(htmlString, htmlTags, injectToStream) {
+    POSITIONS.forEach((position) => {
+        const htmlFragment = htmlTags
+            .filter((h) => h.position === position)
+            .map((h) => resolveHtmlTag(h.htmlTag))
+            .join('');
+        if (htmlFragment) {
+            htmlString = injectHtmlFragment(position, htmlFragment, htmlString, injectToStream);
+        }
+    });
+    return htmlString;
+}
+exports.injectHtmlTags = injectHtmlTags;
+function injectHtmlFragment(position, htmlFragment, htmlString, injectToStream) {
+    if (position === 'HTML_BEGIN') {
+        {
+            const res = injectAtPaceholder(htmlFragment, htmlString, true);
+            if (res)
+                return res;
+        }
+        (0, utils_js_1.assert)(tagOpeningExists('head', htmlString));
+        htmlString = injectAtOpeningTag('head', htmlString, htmlFragment);
+        return htmlString;
+    }
+    if (position === 'HTML_END') {
+        {
+            const res = injectAtPaceholder(htmlFragment, htmlString, false);
+            if (res)
+                return res;
+        }
+        if (tagClosingExists('body', htmlString)) {
+            return injectAtClosingTag('body', htmlString, htmlFragment);
+        }
+        if (tagClosingExists('html', htmlString)) {
+            return injectAtClosingTag('html', htmlString, htmlFragment);
+        }
+        return htmlString + '\n' + htmlFragment;
+    }
+    if (position === 'STREAM') {
+        (0, utils_js_1.assert)(injectToStream);
+        injectToStream(htmlFragment, { flush: true });
+        return htmlString;
+    }
+    (0, utils_js_1.assert)(false);
+}
+function resolveHtmlTag(htmlTag) {
+    return typeof htmlTag !== 'string' ? htmlTag() : htmlTag;
+}
+function injectAtOpeningTag(tag, htmlString, htmlFragment) {
+    const openingTag = getTagOpening(tag);
+    const matches = htmlString.match(openingTag);
+    (0, utils_js_1.assert)(matches && matches.length >= 1);
+    const tagInstance = matches[0];
+    (0, utils_js_1.assert)(tagInstance);
+    const htmlParts = htmlString.split(tagInstance);
+    (0, utils_js_1.assert)(htmlParts.length >= 2);
+    // Insert `htmlFragment` after first `tagInstance`
+    const before = (0, utils_js_1.slice)(htmlParts, 0, 1)[0] + tagInstance;
+    const after = (0, utils_js_1.slice)(htmlParts, 1, 0).join(tagInstance);
+    htmlFragment = injectBreakLines(htmlFragment, before, after);
+    return before + htmlFragment + after;
+}
+exports.injectAtOpeningTag = injectAtOpeningTag;
+function injectAtClosingTag(tag, htmlString, htmlFragment) {
+    const tagClosing = getTagClosing(tag);
+    const matches = htmlString.match(tagClosing);
+    (0, utils_js_1.assert)(matches && matches.length >= 1);
+    const tagInstance = matches[0];
+    (0, utils_js_1.assert)(tagInstance);
+    const htmlParts = htmlString.split(tagInstance);
+    (0, utils_js_1.assert)(htmlParts.length >= 2);
+    // Insert `htmlFragment` before last `tagClosing`
+    const before = (0, utils_js_1.slice)(htmlParts, 0, -1).join(tagInstance);
+    const after = tagInstance + (0, utils_js_1.slice)(htmlParts, -1, 0);
+    htmlFragment = injectBreakLines(htmlFragment, before, after);
+    return before + htmlFragment + after;
+}
+exports.injectAtClosingTag = injectAtClosingTag;
+function injectBreakLines(htmlFragment, before, after) {
+    (0, utils_js_1.assert)(htmlFragment.trim() === htmlFragment);
+    const currentLineBefore = before.split('\n').slice(-1)[0];
+    let paddingParent = currentLineBefore.match(/\s*$/)[0];
+    let isBlankLine = !!paddingParent;
+    if (!paddingParent) {
+        paddingParent = currentLineBefore.match(/^\s*/)[0];
+    }
+    if (!paddingParent)
+        return htmlFragment;
+    const whitespaceExtra = paddingParent ? '  ' : '';
+    const whitespace = `${paddingParent}${whitespaceExtra}`;
+    const padding = `\n${whitespace}`;
+    htmlFragment = htmlFragment.split(/<(?=[^\/])/).join(`${padding}<`);
+    if (isBlankLine) {
+        (0, utils_js_1.assert)(htmlFragment.startsWith(padding), { htmlFragment });
+        htmlFragment = whitespaceExtra + htmlFragment.slice(padding.length);
+    }
+    const currentLineAfter = after.split('\n')[0];
+    if (currentLineAfter.trim().length > 0) {
+        htmlFragment += '\n' + paddingParent;
+    }
+    return htmlFragment;
+}
+function createHtmlHeadIfMissing(htmlString) {
+    const assertion = () => (0, utils_js_1.assert)(tagOpeningExists('head', htmlString) && tagClosingExists('head', htmlString));
+    if (tagOpeningExists('head', htmlString) && tagClosingExists('head', htmlString)) {
+        assertion();
+        return htmlString;
+    }
+    const htmlFragment = '<head></head>';
+    if (tagOpeningExists('html', htmlString)) {
+        htmlString = injectAtOpeningTag('html', htmlString, htmlFragment);
+        assertion();
+        return htmlString;
+    }
+    if (tagOpeningExists('!doctype', htmlString)) {
+        htmlString = injectAtOpeningTag('!doctype', htmlString, htmlFragment);
+        assertion();
+        return htmlString;
+    }
+    htmlString = htmlFragment + '\n' + htmlString;
+    assertion();
+    return htmlString;
+}
+exports.createHtmlHeadIfMissing = createHtmlHeadIfMissing;
+// Pay attention to performance when searching for tags
+// Use the most effective way to test or match tag existence
+// Use tag existence checking with caution as it is costly operation
+function tagOpeningExists(tag, htmlString) {
+    const tagOpeningRE = getTagOpening(tag);
+    return tagOpeningRE.test(htmlString);
+}
+function tagClosingExists(tag, htmlString) {
+    const tagClosingRE = getTagClosing(tag);
+    return tagClosingRE.test(htmlString);
+}
+function getTagOpening(tag) {
+    const tagOpening = new RegExp(`<${tag}(>| [^>]*>)`, 'i');
+    return tagOpening;
+}
+function getTagClosing(tag) {
+    const tagClosing = new RegExp(`</${tag}>`, 'i');
+    return tagClosing;
+}
+function injectAtPaceholder(htmlFragment, htmlString, isFirst) {
+    const placeholder = isFirst ? '__VITE_PLUGIN_SSR__ASSETS_FIRST__' : '__VITE_PLUGIN__SSR_ASSETS_LAST__';
+    const parts = htmlString.split(placeholder);
+    if (parts.length === 1)
+        return null;
+    (0, utils_js_1.assertUsage)(parts.length === 2, "You're inserting assets twice into your HTML", { showStackTrace: true });
+    return [parts[0], htmlFragment, parts[1]].join('');
+}