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

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

@@ -1,161 +0,0 @@
-"use strict";
-// Unit tests at ./injectHtmlTags.spec.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectHtmlTags = injectHtmlTags;
-exports.injectHtmlTagsUsingStream = injectHtmlTagsUsingStream;
-exports.createHtmlHeadIfMissing = createHtmlHeadIfMissing;
-exports.joinHtmlTags = joinHtmlTags;
-exports.injectAtOpeningTag = injectAtOpeningTag;
-exports.injectAtClosingTag = injectAtClosingTag;
-const utils_js_1 = require("../../../utils.js");
-function injectHtmlTags(htmlString, htmlTags, position) {
-    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === position));
-    if (htmlFragment) {
-        htmlString = injectHtmlFragment(position, htmlFragment, htmlString);
-    }
-    return htmlString;
-}
-// Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
-function injectHtmlTagsUsingStream(htmlTags, streamFromReactStreamingPackage) {
-    const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'HTML_STREAM'));
-    if (htmlFragment) {
-        (0, utils_js_1.assert)(!streamFromReactStreamingPackage.hasStreamEnded());
-        streamFromReactStreamingPackage.injectToStream(htmlFragment, { flush: true });
-    }
-}
-function joinHtmlTags(htmlTags) {
-    const htmlFragment = htmlTags.map((h) => resolveHtmlTag(h.htmlTag)).join('');
-    return htmlFragment;
-}
-function injectHtmlFragment(position, htmlFragment, htmlString) {
-    if (position === 'HTML_BEGIN') {
-        {
-            const res = injectAtPlaceholder(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 = injectAtPlaceholder(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;
-    }
-    (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;
-}
-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;
-}
-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.replace(/<[^\/]/g, (match) => `${padding}${match}`);
-    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;
-}
-// 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 injectAtPlaceholder(htmlFragment, htmlString, isFirst) {
-    // TO-DO/eventually: soft deprecate in favor of https://github.com/vikejs/vike/issues/695
-    // Used by BurdaForward https://github.com/vikejs/vike/discussions/2528#discussioncomment-13637156
-    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('');
-}

package/dist/cjs/node/runtime/renderPage/html/injectAssets/mergeScriptTags.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeScriptTags = mergeScriptTags;
-const csp_js_1 = require("../../csp.js");
-const utils_js_1 = require("../../../utils.js");
-const inferHtmlTags_js_1 = require("./inferHtmlTags.js");
-const scriptRE = /(<script\b(?:\s[^>]*>|>))(.*?)<\/script>/gims;
-const srcRE = /\bsrc\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
-const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/im;
-function mergeScriptTags(scriptTagsHtml, pageContext) {
-    let scriptTag = '';
-    const scripts = parseScripts(scriptTagsHtml);
-    // We need to merge module scripts to ensure execution order
-    {
-        const scriptsModule = scripts.filter(({ isModule }) => isModule);
-        if (scriptsModule.length === 1) {
-            scriptTag += scriptsModule[0].outerHtml;
-        }
-        else {
-            const contents = [];
-            scriptsModule.forEach(({ src, innerHtml }) => {
-                const hasInnerHtml = !!innerHtml.trim();
-                if (src) {
-                    (0, utils_js_1.assert)(!hasInnerHtml);
-                    // - We don't use a static import because static imports are hoisted => React's HMR preamble can be executed after user land code => triggering this error:
-                    //   ```
-                    //   [22:28:57.885][/test-dev.test.ts][pnpm run dev][Browser Error] Error: @vitejs/plugin-react-swc can't detect preamble. Something is wrong.
-                    //       at http://localhost:3000/@fs/home/rom/code/docpress/src/renderer/usePageContext.tsx:9:11
-                    //   ```
-                    // - We don't use `await` the dynamic import() to avoid waterfall
-                    contents.push(`import(${JSON.stringify(src)});`);
-                }
-                else if (hasInnerHtml) {
-                    innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');
-                    contents.push(innerHtml);
-                }
-            });
-            if (contents.length > 0) {
-                const nonceAttr = (0, csp_js_1.inferNonceAttr)(pageContext);
-                scriptTag += `<script ${inferHtmlTags_js_1.scriptCommonAttrs}${nonceAttr}>\n${contents.join('\n')}\n</script>`;
-            }
-        }
-    }
-    // We don't need to merge ES5 scripts
-    {
-        const scriptsES5 = scripts.filter(({ isModule }) => !isModule);
-        scriptsES5.forEach(({ outerHtml }) => {
-            scriptTag += outerHtml;
-        });
-    }
-    return scriptTag;
-}
-function parseScripts(htmlString) {
-    const scripts = [];
-    let match;
-    while ((match = scriptRE.exec(htmlString))) {
-        const [outerHtml, openTag, innerHtml] = match;
-        (0, utils_js_1.assert)(outerHtml && openTag && innerHtml !== undefined);
-        let isModule = false;
-        {
-            const typeMatch = openTag.match(typeRE);
-            const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3]);
-            isModule = type === 'module';
-        }
-        let src = null;
-        {
-            const srcMatch = openTag.match(srcRE);
-            src = (srcMatch && (srcMatch[1] || srcMatch[2] || srcMatch[3])) || '';
-        }
-        scripts.push({ isModule, src, innerHtml, outerHtml });
-    }
-    return scripts;
-}

package/dist/cjs/node/runtime/renderPage/html/injectAssets/sanitizeJson.js

@@ -1,8 +0,0 @@
-"use strict";
-// Prevent XSS attacks, see https://github.com/vikejs/vike/pull/181#issuecomment-952846026
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeJson = sanitizeJson;
-function sanitizeJson(unsafe) {
-    const safe = unsafe.replace(/</g, '\\u003c');
-    return safe;
-}

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

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectHtmlTagsToString = injectHtmlTagsToString;
-exports.injectHtmlTagsToStream = injectHtmlTagsToStream;
-const utils_js_1 = require("../../utils.js");
-const assertPageContextProvidedByUser_js_1 = require("../../../../shared/assertPageContextProvidedByUser.js");
-const injectHtmlTags_js_1 = require("./injectAssets/injectHtmlTags.js");
-const getHtmlTags_js_1 = require("./injectAssets/getHtmlTags.js");
-const getViteDevScript_js_1 = require("./injectAssets/getViteDevScript.js");
-async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
-    const pageAssets = await pageContext.__getPageAssets();
-    const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)(pageContext);
-    const htmlTags = await (0, getHtmlTags_js_1.getHtmlTags)(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
-    let htmlString = htmlPartsToString(htmlParts, pageAssets);
-    htmlString = injectToHtmlBegin(htmlString, htmlTags);
-    htmlString = injectToHtmlEnd(htmlString, htmlTags);
-    (0, utils_js_1.assert)(htmlTags.filter((snippet) => snippet.position === 'HTML_STREAM').length === 0);
-    return htmlString;
-}
-function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, injectFilter) {
-    let htmlTags;
-    return {
-        injectAtStreamBegin,
-        injectAtStreamAfterFirstChunk,
-        injectAtStreamEnd,
-    };
-    async function injectAtStreamBegin(htmlPartsBegin) {
-        const pageAssets = await pageContext.__getPageAssets();
-        const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)(pageContext);
-        htmlTags = await (0, getHtmlTags_js_1.getHtmlTags)(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
-        let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
-        htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags);
-        if (streamFromReactStreamingPackage) {
-            (0, injectHtmlTags_js_1.injectHtmlTagsUsingStream)(htmlTags, streamFromReactStreamingPackage);
-        }
-        return htmlBegin;
-    }
-    // Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
-    function injectAtStreamAfterFirstChunk() {
-        // React has its own stream injection mechanism, see injectHtmlTagsUsingStream()
-        if (streamFromReactStreamingPackage)
-            return null;
-        (0, utils_js_1.assert)(htmlTags);
-        const tags = htmlTags.filter((h) => h.position === 'HTML_STREAM');
-        if (tags.length === 0)
-            return null;
-        const htmlFragment = (0, injectHtmlTags_js_1.joinHtmlTags)(tags);
-        return htmlFragment;
-    }
-    async function injectAtStreamEnd(htmlPartsEnd) {
-        (0, utils_js_1.assert)(htmlTags);
-        await resolvePageContextPromise(pageContext);
-        const pageAssets = await pageContext.__getPageAssets();
-        let htmlEnd = htmlPartsToString(htmlPartsEnd, pageAssets);
-        htmlEnd = injectToHtmlEnd(htmlEnd, htmlTags);
-        return htmlEnd;
-    }
-}
-function injectToHtmlBegin(htmlBegin, htmlTags) {
-    // Ensure existence of `<head>`
-    htmlBegin = (0, injectHtmlTags_js_1.createHtmlHeadIfMissing)(htmlBegin);
-    htmlBegin = (0, injectHtmlTags_js_1.injectHtmlTags)(htmlBegin, htmlTags, 'HTML_BEGIN');
-    return htmlBegin;
-}
-function injectToHtmlEnd(htmlEnd, htmlTags) {
-    htmlEnd = (0, injectHtmlTags_js_1.injectHtmlTags)(htmlEnd, htmlTags, 'HTML_END');
-    return htmlEnd;
-}
-async function resolvePageContextPromise(pageContext) {
-    const pageContextPromise = pageContext._pageContextPromise;
-    if (!pageContextPromise) {
-        return;
-    }
-    let pageContextProvidedByUser;
-    if ((0, utils_js_1.isCallable)(pageContextPromise)) {
-        pageContextProvidedByUser = await pageContextPromise();
-    }
-    else if ((0, utils_js_1.isPromise)(pageContextPromise)) {
-        pageContextProvidedByUser = await pageContextPromise;
-    }
-    else {
-        (0, utils_js_1.assert)(false);
-    }
-    (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(pageContextProvidedByUser, pageContext._renderHook);
-    Object.assign(pageContext, pageContextProvidedByUser);
-}
-function htmlPartsToString(htmlParts, pageAssets) {
-    let htmlString = '';
-    htmlParts.forEach((p) => {
-        htmlString += typeof p === 'string' ? p : p(pageAssets);
-    });
-    return htmlString;
-}

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

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropVal = getPropVal;
-exports.setPropVal = setPropVal;
-exports.getPropKeys = getPropKeys;
-const utils_js_1 = require("../../utils.js");
-// Get a nested property from an object using a dot-separated path such as 'user.id'
-function getPropVal(obj, prop) {
-    const keys = getPropKeys(prop);
-    let value = obj;
-    for (const key of keys) {
-        if ((0, utils_js_1.isObject)(value) && key in value) {
-            value = value[key];
-        }
-        else {
-            return null; // Property or intermediate property doesn't exist
-        }
-    }
-    return { value };
-}
-// Set a nested property in an object using a dot-separated path such as 'user.id'
-function setPropVal(obj, prop, val) {
-    const keys = getPropKeys(prop);
-    let currentObj = obj;
-    // Creating intermediate objects if necessary
-    for (let i = 0; i <= keys.length - 2; i++) {
-        const key = keys[i];
-        if (!(key in currentObj)) {
-            // Create intermediate object
-            currentObj[key] = {};
-        }
-        if (!(0, utils_js_1.isObject)(currentObj[key])) {
-            // Skip value upon data structure conflict
-            return;
-        }
-        currentObj = currentObj[key];
-    }
-    // Set the final key to the value
-    const finalKey = keys[keys.length - 1];
-    currentObj[finalKey] = val;
-}
-function getPropKeys(prop) {
-    // Like `prop.split('.')` but with added support for `\` escaping, see getPageContextClientSerialized.spec.ts
-    return prop
-        .split(/(?<!\\)\./) // Split on unescaped dots
-        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
-}

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

@@ -1,245 +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.escapeInject = escapeInject;
-exports.dangerouslySkipEscape = dangerouslySkipEscape;
-exports.renderDocumentHtml = renderDocumentHtml;
-exports.isDocumentHtml = isDocumentHtml;
-exports.getHtmlString = getHtmlString;
-const utils_js_1 = require("../../utils.js");
-const injectAssets_js_1 = require("./injectAssets.js");
-const stream_js_1 = require("./stream.js");
-const react_streaming_js_1 = require("./stream/react-streaming.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function isDocumentHtml(something) {
-    if (isTemplateWrapped(something) || isEscapedString(something) || (0, stream_js_1.isStream)(something)) {
-        (0, utils_js_1.checkType)(something);
-        return true;
-    }
-    return false;
-}
-async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter) {
-    if (isEscapedString(documentHtml)) {
-        (0, utils_js_1.objectAssign)(pageContext, { _isStream: false });
-        let htmlString = getEscapedString(documentHtml);
-        htmlString = await (0, injectAssets_js_1.injectHtmlTagsToString)([htmlString], pageContext, injectFilter);
-        return htmlString;
-    }
-    if ((0, stream_js_1.isStream)(documentHtml)) {
-        (0, utils_js_1.objectAssign)(pageContext, { _isStream: true });
-        const stream = documentHtml;
-        const streamWrapper = await renderHtmlStream(stream, null, pageContext, onErrorWhileStreaming, injectFilter);
-        return streamWrapper;
-    }
-    if (isTemplateWrapped(documentHtml)) {
-        const templateContent = documentHtml._template;
-        const render = renderTemplate(templateContent, pageContext);
-        if (!('htmlStream' in render)) {
-            (0, utils_js_1.objectAssign)(pageContext, { _isStream: false });
-            const { htmlPartsAll } = render;
-            const htmlString = await (0, injectAssets_js_1.injectHtmlTagsToString)(htmlPartsAll, pageContext, injectFilter);
-            return htmlString;
-        }
-        else {
-            (0, utils_js_1.objectAssign)(pageContext, { _isStream: true });
-            const { htmlStream } = render;
-            const streamWrapper = await renderHtmlStream(htmlStream, {
-                htmlPartsBegin: render.htmlPartsBegin,
-                htmlPartsEnd: render.htmlPartsEnd,
-            }, pageContext, onErrorWhileStreaming, injectFilter);
-            return streamWrapper;
-        }
-    }
-    (0, utils_js_1.checkType)(documentHtml);
-    (0, utils_js_1.assert)(false);
-}
-async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
-    const processStreamOptions = {
-        onErrorWhileStreaming,
-        enableEagerStreaming: pageContext.enableEagerStreaming,
-    };
-    if (injectString) {
-        let streamFromReactStreamingPackage = null;
-        if ((0, react_streaming_js_1.isStreamFromReactStreamingPackage)(streamOriginal) && !streamOriginal.disabled) {
-            streamFromReactStreamingPackage = streamOriginal;
-        }
-        const { injectAtStreamBegin, injectAtStreamAfterFirstChunk, injectAtStreamEnd } = (0, injectAssets_js_1.injectHtmlTagsToStream)(pageContext, streamFromReactStreamingPackage, injectFilter);
-        processStreamOptions.injectStringAtBegin = async () => {
-            return await injectAtStreamBegin(injectString.htmlPartsBegin);
-        };
-        processStreamOptions.injectStringAtEnd = async () => {
-            return await injectAtStreamEnd(injectString.htmlPartsEnd);
-        };
-        processStreamOptions.injectStringAfterFirstChunk = () => {
-            return injectAtStreamAfterFirstChunk();
-        };
-    }
-    let makeClosableAgain = () => { };
-    if ((0, react_streaming_js_1.isStreamFromReactStreamingPackage)(streamOriginal)) {
-        // Make sure Vike injects its HTML fragments, such as `<script id="vike_pageContext" type="application/json">`, before the stream is closed (if React/Vue finishes its stream before the promise below resolves).
-        makeClosableAgain = streamOriginal.doNotClose();
-    }
-    try {
-        const streamWrapper = await (0, stream_js_1.processStream)(streamOriginal, processStreamOptions);
-        return streamWrapper;
-    }
-    finally {
-        makeClosableAgain();
-    }
-}
-function isTemplateWrapped(something) {
-    return (0, utils_js_1.hasProp)(something, '_template');
-}
-function isEscapedString(something) {
-    const result = (0, utils_js_1.hasProp)(something, '_escaped');
-    if (result) {
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(something, '_escaped', 'string'));
-        (0, utils_js_1.checkType)(something);
-    }
-    return result;
-}
-function getEscapedString(escapedString) {
-    let htmlString;
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(escapedString, '_escaped'));
-    htmlString = escapedString._escaped;
-    (0, utils_js_1.assert)(typeof htmlString === 'string');
-    return htmlString;
-}
-function escapeInject(templateStrings, ...templateVariables) {
-    (0, utils_js_1.assertUsage)(templateStrings.length === templateVariables.length + 1 && templateStrings.every((str) => typeof str === 'string'), `You're using ${picocolors_1.default.cyan('escapeInject')} as a function, but ${picocolors_1.default.cyan('escapeInject')} is a string template tag, see https://vike.dev/escapeInject`, { showStackTrace: true });
-    return {
-        _template: {
-            templateStrings,
-            templateVariables: templateVariables,
-        },
-    };
-}
-function dangerouslySkipEscape(alreadyEscapedString) {
-    return _dangerouslySkipEscape(alreadyEscapedString);
-}
-function _dangerouslySkipEscape(arg) {
-    if ((0, utils_js_1.hasProp)(arg, '_escaped')) {
-        (0, utils_js_1.assert)(isEscapedString(arg));
-        return arg;
-    }
-    (0, utils_js_1.assertUsage)(!(0, utils_js_1.isPromise)(arg), `[dangerouslySkipEscape(${picocolors_1.default.cyan('str')})] Argument ${picocolors_1.default.cyan('str')} is a promise. It should be a string instead (or a stream). Make sure to ${picocolors_1.default.cyan('await str')}.`, { showStackTrace: true });
-    if (typeof arg === 'string') {
-        return { _escaped: arg };
-    }
-    (0, utils_js_1.assertWarning)(false, `[dangerouslySkipEscape(${picocolors_1.default.cyan('str')})] Argument ${picocolors_1.default.cyan('str')} should be a string but we got ${picocolors_1.default.cyan(`typeof str === "${typeof arg}"`)}.`, {
-        onlyOnce: false,
-        showStackTrace: true,
-    });
-    return { _escaped: String(arg) };
-}
-function renderTemplate(templateContent, pageContext) {
-    const htmlPartsBegin = [];
-    const htmlPartsEnd = [];
-    let htmlStream = null;
-    const addHtmlPart = (htmlPart) => {
-        if (htmlStream === null) {
-            htmlPartsBegin.push(htmlPart);
-        }
-        else {
-            htmlPartsEnd.push(htmlPart);
-        }
-    };
-    const setStream = (stream) => {
-        const { hookName, hookFilePath } = pageContext._renderHook;
-        (0, utils_js_1.assertUsage)(!htmlStream, `Injecting two streams in ${picocolors_1.default.cyan('escapeInject')} template tag of ${hookName}() hook defined by ${hookFilePath}. Inject only one stream instead.`);
-        htmlStream = stream;
-    };
-    const { templateStrings, templateVariables } = templateContent;
-    for (let i = 0; i < templateVariables.length; i++) {
-        addHtmlPart(templateStrings[i]);
-        let templateVar = templateVariables[i];
-        // Process `dangerouslySkipEscape()`
-        if (isEscapedString(templateVar)) {
-            const htmlString = getEscapedString(templateVar);
-            // User used `dangerouslySkipEscape()` so we assume the string to be safe
-            addHtmlPart(htmlString);
-            continue;
-        }
-        // Process `escapeInject` fragments
-        if (isTemplateWrapped(templateVar)) {
-            const templateContentInner = templateVar._template;
-            const result = renderTemplate(templateContentInner, pageContext);
-            if (!('htmlStream' in result)) {
-                result.htmlPartsAll.forEach(addHtmlPart);
-            }
-            else {
-                result.htmlPartsBegin.forEach(addHtmlPart);
-                setStream(result.htmlStream);
-                result.htmlPartsEnd.forEach(addHtmlPart);
-            }
-            continue;
-        }
-        if ((0, stream_js_1.isStream)(templateVar)) {
-            setStream(templateVar);
-            continue;
-        }
-        const getErrMsg = (msg) => {
-            const { hookName, hookFilePath } = pageContext._renderHook;
-            const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
-            return [
-                `The ${nth} HTML variable is ${msg}`,
-                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`,
-            ]
-                .filter(Boolean)
-                .join(' ');
-        };
-        (0, utils_js_1.assertUsage)(!(0, utils_js_1.isPromise)(templateVar), getErrMsg(`a promise, did you forget to ${picocolors_1.default.cyan('await')} the promise?`));
-        if (templateVar === undefined || templateVar === null) {
-            const msgVal = picocolors_1.default.cyan(String(templateVar));
-            const msgEmptyString = picocolors_1.default.cyan("''");
-            const msg = `${msgVal} which will be converted to an empty string. Pass the empty string ${msgEmptyString} instead of ${msgVal} to remove this warning.`;
-            (0, utils_js_1.assertWarning)(false, getErrMsg(msg), { onlyOnce: false });
-            templateVar = '';
-        }
-        {
-            const varType = typeof templateVar;
-            if (varType !== 'string') {
-                const msgType = picocolors_1.default.cyan(`typeof htmlVariable === "${varType}"`);
-                const msg = `${msgType} but a string or stream (https://vike.dev/streaming) is expected instead.`;
-                (0, utils_js_1.assertUsage)(false, getErrMsg(msg));
-            }
-        }
-        {
-            const { _isProduction: isProduction } = pageContext._globalContext;
-            if ((0, utils_js_1.isHtml)(templateVar) &&
-                // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
-                !isProduction) {
-                const msgVal = picocolors_1.default.cyan(String(templateVar));
-                const msg = `${msgVal} which seems to be HTML code. Did you forget to wrap the value with dangerouslySkipEscape()?`;
-                (0, utils_js_1.assertWarning)(false, getErrMsg(msg), { onlyOnce: false });
-            }
-        }
-        // Escape untrusted template variable
-        addHtmlPart((0, utils_js_1.escapeHtml)(templateVar));
-    }
-    (0, utils_js_1.assert)(templateStrings.length === templateVariables.length + 1);
-    addHtmlPart(templateStrings[templateStrings.length - 1]);
-    if (htmlStream === null) {
-        (0, utils_js_1.assert)(htmlPartsEnd.length === 0);
-        return {
-            htmlPartsAll: htmlPartsBegin,
-        };
-    }
-    return {
-        htmlStream,
-        htmlPartsBegin,
-        htmlPartsEnd,
-    };
-}
-async function getHtmlString(htmlRender) {
-    if (typeof htmlRender === 'string') {
-        return htmlRender;
-    }
-    if ((0, stream_js_1.isStream)(htmlRender)) {
-        return (0, stream_js_1.streamToString)(htmlRender);
-    }
-    (0, utils_js_1.checkType)(htmlRender);
-    (0, utils_js_1.assert)(false);
-}