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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeScriptTags = void 0;
+const utils_js_1 = require("../../utils.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, isProduction) {
+    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);
+                    if (isProduction) {
+                        contents.push(`import ${JSON.stringify(src)};`);
+                    }
+                    else {
+                        // Ensure HMR preamble code is executed before client entries
+                        contents.push(`import(${JSON.stringify(src)});`);
+                    }
+                }
+                else if (hasInnerHtml) {
+                    innerHtml = innerHtml.split('\n').filter(Boolean).join('\n');
+                    contents.push(innerHtml);
+                }
+            });
+            if (contents.length > 0) {
+                scriptTag += `<script type="module" defer>\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;
+}
+exports.mergeScriptTags = mergeScriptTags;
+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/html/injectAssets/sanitizeJson.js

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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectHtmlTagsToStream = exports.injectHtmlTagsToString = void 0;
+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");
+async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
+    const htmlTags = await (0, getHtmlTags_js_1.getHtmlTags)(pageContext, null, injectFilter);
+    const pageAssets = await pageContext.__getPageAssets();
+    let htmlString = htmlPartsToString(htmlParts, pageAssets);
+    htmlString = injectToHtmlBegin(htmlString, htmlTags, null);
+    htmlString = injectToHtmlEnd(htmlString, htmlTags);
+    return htmlString;
+}
+exports.injectHtmlTagsToString = injectHtmlTagsToString;
+function injectHtmlTagsToStream(pageContext, injectToStream, injectFilter) {
+    let htmlTags;
+    return {
+        injectAtStreamBegin,
+        injectAtStreamEnd
+    };
+    async function injectAtStreamBegin(htmlPartsBegin) {
+        htmlTags = await (0, getHtmlTags_js_1.getHtmlTags)(pageContext, injectToStream, injectFilter);
+        const pageAssets = await pageContext.__getPageAssets();
+        let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
+        htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags, injectToStream);
+        return htmlBegin;
+    }
+    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;
+    }
+}
+exports.injectHtmlTagsToStream = injectHtmlTagsToStream;
+function injectToHtmlBegin(htmlBegin, htmlTags, injectToStream) {
+    const htmlTagsAtBegin = htmlTags.filter((snippet) => snippet.position !== 'HTML_END');
+    // Ensure existence of `<head>`
+    htmlBegin = (0, injectHtmlTags_js_1.createHtmlHeadIfMissing)(htmlBegin);
+    htmlBegin = (0, injectHtmlTags_js_1.injectHtmlTags)(htmlBegin, htmlTagsAtBegin, injectToStream);
+    return htmlBegin;
+}
+function injectToHtmlEnd(htmlEnd, htmlTags) {
+    const htmlTagsAtEnd = htmlTags.filter((snippet) => snippet.position === 'HTML_END');
+    htmlEnd = (0, injectHtmlTags_js_1.injectHtmlTags)(htmlEnd, htmlTagsAtEnd, null);
+    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/html/renderHtml.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHtmlString = exports.isDocumentHtml = exports.renderDocumentHtml = exports.dangerouslySkipEscape = exports.escapeInject = void 0;
+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 globalContext_js_1 = require("../globalContext.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;
+}
+exports.isDocumentHtml = isDocumentHtml;
+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 = await 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);
+}
+exports.renderDocumentHtml = renderDocumentHtml;
+async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
+    const opts = {
+        onErrorWhileStreaming,
+        enableEagerStreaming: pageContext.enableEagerStreaming
+    };
+    if (injectString) {
+        let injectToStream = null;
+        if ((0, react_streaming_js_1.isStreamReactStreaming)(streamOriginal) && !streamOriginal.disabled) {
+            injectToStream = streamOriginal.injectToStream;
+        }
+        const { injectAtStreamBegin, injectAtStreamEnd } = (0, injectAssets_js_1.injectHtmlTagsToStream)(pageContext, injectToStream, injectFilter);
+        (0, utils_js_1.objectAssign)(opts, {
+            injectStringAtBegin: async () => {
+                return await injectAtStreamBegin(injectString.htmlPartsBegin);
+            },
+            injectStringAtEnd: async () => {
+                return await injectAtStreamEnd(injectString.htmlPartsEnd);
+            }
+        });
+    }
+    const streamWrapper = await (0, stream_js_1.processStream)(streamOriginal, opts);
+    return streamWrapper;
+}
+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
+        }
+    };
+}
+exports.escapeInject = escapeInject;
+function dangerouslySkipEscape(alreadyEscapedString) {
+    return _dangerouslySkipEscape(alreadyEscapedString);
+}
+exports.dangerouslySkipEscape = dangerouslySkipEscape;
+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) };
+}
+async 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 = await 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 = (typeText, end) => {
+            const { hookName, hookFilePath } = pageContext._renderHook;
+            const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
+            return [`The ${nth} HTML variable is ${typeText}, see ${hookName}() hook defined by ${hookFilePath}.`, end]
+                .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) {
+            (0, utils_js_1.assertWarning)(false, getErrMsg(`${picocolors_1.default.cyan(String(templateVar))} which will be converted to an empty string`, `Pass an empty string instead of ${picocolors_1.default.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
+            templateVar = '';
+        }
+        {
+            const varType = typeof templateVar;
+            const streamNote = ['boolean', 'number', 'bigint', 'symbol'].includes(varType)
+                ? null
+                : '(See https://vike.dev/stream for HTML streaming.)';
+            (0, utils_js_1.assertUsage)(varType === 'string', getErrMsg(picocolors_1.default.cyan(`typeof htmlVar === "${varType}"`), streamNote));
+        }
+        {
+            const { isProduction } = (0, globalContext_js_1.getGlobalContext)();
+            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) {
+                (0, utils_js_1.assertWarning)(false, getErrMsg(`${picocolors_1.default.cyan(templateVar)} which seems to be HTML code`, 'Did you forget to wrap the value with dangerouslySkipEscape()?'), { onlyOnce: false });
+            }
+        }
+        // Escape untrusted template variable
+        addHtmlPart(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
+    };
+}
+function escapeHtml(unsafeString) {
+    // Source: https://stackoverflow.com/questions/6234773/can-i-escape-html-special-chars-in-javascript/6234804#6234804
+    const safe = unsafeString
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+    return safe;
+}
+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);
+}
+exports.getHtmlString = getHtmlString;

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializePageContextAbort = exports.serializePageContextClientSide = void 0;
+const stringify_1 = require("@brillout/json-serializer/stringify");
+const utils_js_1 = require("../utils.js");
+const error_page_js_1 = require("../../../shared/error-page.js");
+const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const notSerializable_js_1 = require("../../../shared/notSerializable.js");
+const PASS_TO_CLIENT = [
+    'abortReason',
+    '_urlRewrite',
+    '_urlRedirect',
+    'abortStatusCode',
+    '_abortCall',
+    /* Not needed on the client-side
+    '_abortCaller',
+    */
+    '_pageContextInitHasClientData',
+    '_pageId'
+];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', '_isError'];
+function serializePageContextClientSide(pageContext) {
+    const passToClient = getPassToClient(pageContext);
+    const pageContextClient = {};
+    passToClient.forEach((prop) => {
+        // We set non-existing props to `undefined`, in order to pass the list of passToClient values to the client-side
+        pageContextClient[prop] = pageContext[prop];
+    });
+    if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
+        pageContextClient._pageContextInitHasClientData = true;
+    }
+    let pageContextSerialized;
+    try {
+        pageContextSerialized = serialize(pageContextClient);
+    }
+    catch (err) {
+        const h = (s) => picocolors_1.default.cyan(s);
+        let hasWarned = false;
+        const propsNonSerializable = [];
+        passToClient.forEach((prop) => {
+            const propName = JSON.stringify(prop);
+            const varName = h(`pageContext[${propName}]`);
+            try {
+                serialize(pageContext[prop], varName);
+            }
+            catch (err) {
+                hasWarned = true;
+                propsNonSerializable.push(prop);
+                (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
+                (0, utils_js_1.assertWarning)(false, [
+                    `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
+                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`,
+                    `Serialization error: ${err.messageCore}.`
+                ].join(' '), { onlyOnce: false });
+            }
+        });
+        (0, utils_js_1.assert)(hasWarned);
+        propsNonSerializable.forEach((prop) => {
+            pageContextClient[prop] = notSerializable_js_1.notSerializable;
+        });
+        pageContextSerialized = serialize(pageContextClient);
+    }
+    return pageContextSerialized;
+}
+exports.serializePageContextClientSide = serializePageContextClientSide;
+function serialize(value, varName) {
+    return (0, stringify_1.stringify)(value, { forbidReactElements: true, valueName: varName });
+}
+function getPassToClient(pageContext) {
+    let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
+    if ((0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs)) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
+        (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
+        passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);
+    }
+    passToClient = (0, utils_js_1.unique)(passToClient);
+    return passToClient;
+}
+function serializePageContextAbort(pageContext) {
+    (0, utils_js_1.assert)(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
+    (0, utils_js_1.assert)(pageContext._abortCall);
+    (0, utils_js_1.assert)(pageContext._abortCaller);
+    // Not needed on the client-side
+    delete pageContext._abortCaller;
+    const unknownProps = Object.keys(pageContext).filter((prop) => ![
+        // prettier-ignore
+        '_abortCall',
+        /* Not needed on the client-side
+        '_abortCaller',
+        */
+        '_urlRedirect',
+        '_urlRewrite',
+        'abortStatusCode',
+        'abortReason',
+        'is404',
+        'pageProps'
+    ].includes(prop));
+    if (!pageContext._isLegacyRenderErrorPage) {
+        (0, utils_js_1.assert)(unknownProps.length === 0);
+    }
+    else {
+        // TODO/v1-release: remove
+        (0, utils_js_1.assertWarning)(unknownProps.length === 0, [
+            "The following pageContext values won't be available on the client-side:",
+            unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
+            'Use `throw render()` instead of `throw RenderErrorPage()`'
+        ].join('\n'), {
+            onlyOnce: false
+        });
+    }
+    return serialize(pageContext);
+}
+exports.serializePageContextAbort = serializePageContextAbort;

package/dist/cjs/node/runtime/html/stream/react-streaming.js

@@ -0,0 +1,36 @@
+"use strict";
+// Zero-config support for https://www.npmjs.com/package/react-streaming
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamFromReactStreaming = exports.streamReactStreamingToString = exports.isStreamReactStreaming = void 0;
+const utils_js_1 = require("../../utils.js");
+const stream_js_1 = require("../stream.js");
+function streamReactStreamingToString(stream) {
+    if (stream.pipe) {
+        return (0, stream_js_1.streamPipeNodeToString)(stream.pipe);
+    }
+    if (stream.readable) {
+        return (0, stream_js_1.streamReadableWebToString)(stream.readable);
+    }
+    (0, utils_js_1.assert)(false);
+}
+exports.streamReactStreamingToString = streamReactStreamingToString;
+function isStreamReactStreaming(thing) {
+    if ((0, utils_js_1.hasProp)(thing, 'injectToStream', 'function')) {
+        return true;
+    }
+    // TODO
+    //if( isStreamPipeNode
+    return false;
+}
+exports.isStreamReactStreaming = isStreamReactStreaming;
+function getStreamFromReactStreaming(stream) {
+    if (stream.pipe) {
+        // TODO
+        return { __streamPipeNode: stream.pipe };
+    }
+    if (stream.readable) {
+        return stream.readable;
+    }
+    (0, utils_js_1.assert)(false);
+}
+exports.getStreamFromReactStreaming = getStreamFromReactStreaming;