@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/cjs/core/server/stream/beforeTemplate.js

@@ -0,0 +1,111 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildShellBeforeTemplate: ()=>buildShellBeforeTemplate
+});
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const external_react_helmet_namespaceObject = require("react-helmet");
+var external_react_helmet_default = /*#__PURE__*/ __webpack_require__.n(external_react_helmet_namespaceObject);
+const lifecycle_js_namespaceObject = require("../../../router/runtime/lifecycle.js");
+const external_constants_js_namespaceObject = require("../constants.js");
+const external_helmet_js_namespaceObject = require("../helmet.js");
+const external_shared_js_namespaceObject = require("../shared.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const readAsset = async (chunk)=>{
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filepath = path.join(__dirname, chunk);
+    return fs.readFile(filepath, 'utf-8');
+};
+const checkIsInline = (chunk, enableInline)=>{
+    if ('production' !== process.env.NODE_ENV) return false;
+    if (enableInline instanceof RegExp) return enableInline.test(chunk);
+    return Boolean(enableInline);
+};
+async function buildShellBeforeTemplate(beforeAppTemplate, options) {
+    const { config, runtimeContext, styledComponentsStyleTags, entryName } = options;
+    const helmetData = external_react_helmet_default().renderStatic();
+    const callbacks = [
+        (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
+        (template)=>injectCss(template, entryName, styledComponentsStyleTags)
+    ];
+    return (0, external_shared_js_namespaceObject.buildHtml)(beforeAppTemplate, callbacks);
+    async function injectCss(template, entryName, styledComponentsStyleTags) {
+        let css = await getCssChunks();
+        if (styledComponentsStyleTags) css += styledComponentsStyleTags;
+        return (0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject.CHUNK_CSS_PLACEHOLDER, css);
+        async function getCssChunks() {
+            const { routeManifest, routerContext, routes } = runtimeContext;
+            if (!routeManifest) return '';
+            const { routeAssets } = routeManifest;
+            let matchedRouteManifests;
+            const matchedRouteIds = (0, lifecycle_js_namespaceObject.getRouterMatchedRouteIds)(runtimeContext);
+            if (matchedRouteIds?.length) matchedRouteManifests = matchedRouteIds.map((routeId)=>routeAssets[routeId]).filter(Boolean);
+            else {
+                if (!routerContext || !routes) return '';
+                const matches = (0, router_namespaceObject.matchRoutes)(routes, routerContext.location, routerContext.basename);
+                matchedRouteManifests = matches?.map((match, index)=>{
+                    if (!index) return;
+                    const routeId = match.route.id;
+                    if (routeId) return routeAssets[routeId];
+                }).filter(Boolean);
+            }
+            const asyncEntry = routeAssets[`async-${entryName}`];
+            if (asyncEntry) matchedRouteManifests?.push(asyncEntry);
+            const cssChunks = matchedRouteManifests ? matchedRouteManifests.reduce((chunks, routeManifest)=>{
+                const { referenceCssAssets = [] } = routeManifest;
+                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !template.includes(asset));
+                return [
+                    ...chunks,
+                    ..._cssChunks
+                ];
+            }, []) : [];
+            const { inlineStyles } = config;
+            const styles = await Promise.all(cssChunks.map(async (chunk)=>{
+                const link = `<link href="${chunk}" rel="stylesheet" />`;
+                if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
+                return link;
+            }));
+            return `${styles.join('')}`;
+        }
+    }
+}
+exports.buildShellBeforeTemplate = __webpack_exports__.buildShellBeforeTemplate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildShellBeforeTemplate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/stream/createReadableStream.js

@@ -0,0 +1,161 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createReadableStreamFromElement: ()=>createReadableStreamFromElement
+});
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const external_stream_namespaceObject = require("stream");
+const external_common_js_namespaceObject = require("../../../common.js");
+const external_constants_js_namespaceObject = require("../../constants.js");
+const index_js_namespaceObject = require("../../context/index.js");
+const monitors_index_js_namespaceObject = require("../../context/monitors/index.js");
+const external_deferredScript_js_namespaceObject = require("./deferredScript.js");
+const external_shared_js_namespaceObject = require("./shared.js");
+const external_template_js_namespaceObject = require("./template.js");
+const defaultExtender = {
+    modifyRootElement: (rootElement)=>rootElement,
+    getStyleTags: ()=>'',
+    processStream: (stream)=>stream
+};
+const createReadableStreamFromElement = async (request, rootElement, options)=>{
+    const { renderToPipeableStream } = await import("react-dom/server");
+    const { runtimeContext, htmlTemplate, config, ssrConfig, entryName } = options;
+    let shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.START;
+    let renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
+    const forceStream2String = Boolean(process.env.MODERN_JS_STREAM_TO_STRING);
+    const { onReady } = (0, external_shared_js_namespaceObject.resolveStreamingMode)(request, forceStream2String);
+    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const hooks = internalRuntimeContext.hooks;
+    const extenders = hooks.extendStreamSSR.call() || [];
+    if (0 === extenders.length) extenders.push(defaultExtender);
+    extenders.forEach((extender)=>{
+        if (extender.init) extender.init({
+            rootElement,
+            forceStream2String
+        });
+    });
+    let processedRootElement = rootElement;
+    extenders.forEach((extender)=>{
+        if (extender.modifyRootElement) processedRootElement = extender.modifyRootElement(processedRootElement);
+    });
+    const chunkVec = [];
+    return new Promise((resolve)=>{
+        const { pipe: reactStreamingPipe } = renderToPipeableStream(processedRootElement, {
+            nonce: config.nonce,
+            identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX,
+            [onReady] () {
+                let styledComponentsStyleTags = '';
+                extenders.forEach((extender)=>{
+                    if (extender.getStyleTags) styledComponentsStyleTags += extender.getStyleTags();
+                });
+                options[onReady]?.();
+                (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+                    request,
+                    ssrConfig,
+                    renderLevel,
+                    runtimeContext,
+                    config,
+                    entryName,
+                    styledComponentsStyleTags
+                }).then(({ shellAfter, shellBefore })=>{
+                    const pendingScripts = [];
+                    const body = new external_stream_namespaceObject.Transform({
+                        transform (chunk, _encoding, callback) {
+                            try {
+                                if (shellChunkStatus !== external_shared_js_namespaceObject.ShellChunkStatus.FINISH) {
+                                    chunkVec.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                                    const chunkStr = chunk.toString('utf-8');
+                                    if (chunkStr.includes(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK)) {
+                                        let concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
+                                        concatedChunk = concatedChunk.replace(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK, '');
+                                        shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.FINISH;
+                                        this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+                                        if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
+                                    }
+                                } else this.push(chunk);
+                                callback();
+                            } catch (e) {
+                                e instanceof Error ? callback(e) : callback(new Error('Received unknown error when streaming'));
+                            }
+                        }
+                    });
+                    const passThrough = new external_stream_namespaceObject.PassThrough();
+                    const stream = external_stream_namespaceObject.Readable.toWeb(body);
+                    resolve(stream);
+                    let processedStream = passThrough;
+                    extenders.forEach((extender)=>{
+                        if (extender.processStream) processedStream = extender.processStream(processedStream);
+                    });
+                    reactStreamingPipe(passThrough);
+                    processedStream.pipe(body);
+                    try {
+                        const storageContext = node_namespaceObject.storage.useContext?.();
+                        const activeDeferreds = storageContext?.activeDeferreds;
+                        const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
+                        if (entries.length > 0) {
+                            const enqueueScript = (s)=>{
+                                if (shellChunkStatus === external_shared_js_namespaceObject.ShellChunkStatus.FINISH) body.write(s);
+                                else pendingScripts.push(s);
+                            };
+                            (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, (s)=>enqueueScript(s));
+                        }
+                    } catch (err) {
+                        const monitors = (0, monitors_index_js_namespaceObject.getMonitors)();
+                        monitors.error("cannot inject router data script", err);
+                    }
+                });
+            },
+            onShellError (error) {
+                renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+                (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+                    request,
+                    ssrConfig,
+                    renderLevel,
+                    runtimeContext,
+                    entryName,
+                    config
+                }).then(({ shellAfter, shellBefore })=>{
+                    const fallbackHtml = `${shellBefore}${shellAfter}`;
+                    const readableStream = (0, external_shared_js_namespaceObject.getReadableStreamFromString)(fallbackHtml);
+                    resolve(readableStream);
+                    options?.onShellError?.(error);
+                });
+            },
+            onError (error) {
+                renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+                options?.onError?.(error);
+            }
+        });
+    });
+};
+exports.createReadableStreamFromElement = __webpack_exports__.createReadableStreamFromElement;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createReadableStreamFromElement"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/stream/createReadableStream.worker.js

@@ -0,0 +1,141 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createReadableStreamFromElement: ()=>createReadableStreamFromElement
+});
+const ssr_namespaceObject = require("@modern-js/render/ssr");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const external_common_js_namespaceObject = require("../../../common.js");
+const external_constants_js_namespaceObject = require("../../constants.js");
+const external_deferredScript_js_namespaceObject = require("./deferredScript.js");
+const external_shared_js_namespaceObject = require("./shared.js");
+const external_template_js_namespaceObject = require("./template.js");
+const createReadableStreamFromElement = async (request, rootElement, options)=>{
+    let shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.START;
+    const chunkVec = [];
+    const { htmlTemplate, runtimeContext, config, ssrConfig, entryName, rscRoot } = options;
+    const { shellBefore, shellAfter } = await (0, external_template_js_namespaceObject.getTemplates)(htmlTemplate, {
+        renderLevel: external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER,
+        runtimeContext,
+        ssrConfig,
+        request,
+        config,
+        entryName
+    });
+    try {
+        const readableOriginal = await (0, ssr_namespaceObject.renderSSRStream)(rootElement, {
+            request,
+            nonce: config.nonce,
+            rscRoot: rscRoot,
+            routes: runtimeContext.routes,
+            onError (error) {
+                options.onError?.(error);
+            }
+        });
+        options.onShellReady?.();
+        readableOriginal.allReady.then(()=>{
+            options?.onAllReady?.();
+        });
+        const forceStreamToString = Boolean("u" > typeof process && process.env?.MODERN_JS_STREAM_TO_STRING);
+        const { waitForAllReady } = (0, external_shared_js_namespaceObject.resolveStreamingMode)(request, forceStreamToString);
+        if (waitForAllReady) await readableOriginal.allReady;
+        const reader = readableOriginal.getReader();
+        const stream = new ReadableStream({
+            start (controller) {
+                const pendingScripts = [];
+                let isClosed = false;
+                const safeEnqueue = (chunk)=>{
+                    if (isClosed) return;
+                    try {
+                        controller.enqueue(chunk);
+                    } catch  {
+                        isClosed = true;
+                    }
+                };
+                const closeController = ()=>{
+                    if (!isClosed) {
+                        isClosed = true;
+                        try {
+                            controller.close();
+                        } catch  {}
+                    }
+                };
+                const flushPendingScripts = ()=>{
+                    for (const s of pendingScripts)safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(s));
+                    pendingScripts.length = 0;
+                };
+                const enqueueScript = (script)=>{
+                    if (shellChunkStatus === external_shared_js_namespaceObject.ShellChunkStatus.FINISH) safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(script));
+                    else pendingScripts.push(script);
+                };
+                const storageContext = node_namespaceObject.storage.useContext?.();
+                const activeDeferreds = storageContext?.activeDeferreds;
+                const entries = activeDeferreds instanceof Map ? Array.from(activeDeferreds.entries()) : [];
+                if (entries.length > 0) (0, external_deferredScript_js_namespaceObject.enqueueFromEntries)(entries, config.nonce, enqueueScript);
+                async function push() {
+                    try {
+                        const { done, value } = await reader.read();
+                        if (done) return void closeController();
+                        if (isClosed) return;
+                        if (shellChunkStatus !== external_shared_js_namespaceObject.ShellChunkStatus.FINISH) {
+                            chunkVec.push(new TextDecoder().decode(value));
+                            const concatedChunk = chunkVec.join('');
+                            if (concatedChunk.includes(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK)) {
+                                shellChunkStatus = external_shared_js_namespaceObject.ShellChunkStatus.FINISH;
+                                safeEnqueue((0, external_shared_js_namespaceObject.encodeForWebStream)(`${shellBefore}${concatedChunk.replace(external_common_js_namespaceObject.ESCAPED_SHELL_STREAM_END_MARK, '')}${shellAfter}`));
+                                flushPendingScripts();
+                            }
+                        } else safeEnqueue(value);
+                        if (!isClosed) push();
+                    } catch (error) {
+                        if (!isClosed) {
+                            isClosed = true;
+                            try {
+                                controller.error(error);
+                            } catch  {}
+                        }
+                    }
+                }
+                push();
+            },
+            cancel (reason) {
+                reader.cancel(reason).catch(()=>{});
+            }
+        });
+        return stream;
+    } catch (e) {
+        const fallbackHtml = `${shellBefore}${shellAfter}`;
+        const stream = (0, external_shared_js_namespaceObject.getReadableStreamFromString)(fallbackHtml);
+        return stream;
+    }
+};
+exports.createReadableStreamFromElement = __webpack_exports__.createReadableStreamFromElement;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createReadableStreamFromElement"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/stream/deferredScript.js

@@ -0,0 +1,114 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildDeferredDataScript: ()=>buildDeferredDataScript,
+    enqueueFromEntries: ()=>enqueueFromEntries,
+    escapeAttr: ()=>escapeAttr,
+    isDeferredDataLike: ()=>isDeferredDataLike,
+    isPromiseLike: ()=>isPromiseLike,
+    isRecord: ()=>isRecord,
+    toErrorInfo: ()=>toErrorInfo
+});
+const constants_js_namespaceObject = require("../../../router/runtime/constants.js");
+const HTML_ESCAPE_MAP = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;'
+};
+function escapeAttr(value) {
+    return value.replace(/[&<>"']/g, (ch)=>HTML_ESCAPE_MAP[ch]);
+}
+function isRecord(v) {
+    return 'object' == typeof v && null !== v;
+}
+function isDeferredDataLike(v) {
+    if (!isRecord(v)) return false;
+    const hasPending = 'pendingKeys' in v && Array.isArray(v.pendingKeys);
+    const hasData = 'data' in v && isRecord(v.data);
+    return hasPending && hasData;
+}
+function isPromiseLike(value) {
+    return !!value && 'function' == typeof value.then;
+}
+function toErrorInfo(error) {
+    if (error && 'object' == typeof error) {
+        const maybeMsg = error.message;
+        const maybeStack = error.stack;
+        return {
+            message: 'string' == typeof maybeMsg ? maybeMsg : String(maybeMsg ?? error),
+            stack: 'production' !== process.env.NODE_ENV ? maybeStack : void 0
+        };
+    }
+    return {
+        message: String(error)
+    };
+}
+function buildDeferredDataScript(nonce, args) {
+    const payload = JSON.stringify(args);
+    const escaped = escapeAttr(payload);
+    const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
+    return `<script async${nonceAttr} data-fn-name="r" data-script-src="modern-run-router-data-fn" data-fn-args='${escaped}' suppressHydrationWarning>${constants_js_namespaceObject.runRouterDataFnStr}</script>`;
+}
+function enqueueFromEntries(entries, nonce, emit) {
+    entries.forEach(([routeId, value])=>{
+        if (!isDeferredDataLike(value)) return;
+        const pendingKeys = new Set(value.pendingKeys ?? []);
+        pendingKeys.forEach((key)=>{
+            const tracked = value.data?.[key];
+            if (isPromiseLike(tracked)) tracked.then((val)=>emit(buildDeferredDataScript(nonce, [
+                    routeId,
+                    key,
+                    val
+                ])), (err)=>emit(buildDeferredDataScript(nonce, [
+                    routeId,
+                    key,
+                    void 0,
+                    toErrorInfo(err)
+                ])));
+        });
+    });
+}
+exports.buildDeferredDataScript = __webpack_exports__.buildDeferredDataScript;
+exports.enqueueFromEntries = __webpack_exports__.enqueueFromEntries;
+exports.escapeAttr = __webpack_exports__.escapeAttr;
+exports.isDeferredDataLike = __webpack_exports__.isDeferredDataLike;
+exports.isPromiseLike = __webpack_exports__.isPromiseLike;
+exports.isRecord = __webpack_exports__.isRecord;
+exports.toErrorInfo = __webpack_exports__.toErrorInfo;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildDeferredDataScript",
+    "enqueueFromEntries",
+    "escapeAttr",
+    "isDeferredDataLike",
+    "isPromiseLike",
+    "isRecord",
+    "toErrorInfo"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/stream/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    renderStreaming: ()=>renderStreaming
+});
+const external_shared_js_namespaceObject = require("./shared.js");
+const createReadableStreamFromElement = 'edge' === process.env.MODERN_SSR_ENV ? import("./createReadableStream.worker.js").then((m)=>m.createReadableStreamFromElement) : import("./createReadableStream.js").then((m)=>m.createReadableStreamFromElement);
+const renderStreaming = (0, external_shared_js_namespaceObject.createRenderStreaming)(createReadableStreamFromElement);
+exports.renderStreaming = __webpack_exports__.renderStreaming;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderStreaming"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});