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

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

@@ -0,0 +1,154 @@
+"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__, {
+    ShellChunkStatus: ()=>shared_ShellChunkStatus,
+    createRenderStreaming: ()=>createRenderStreaming,
+    encodeForWebStream: ()=>encodeForWebStream,
+    getReadableStreamFromString: ()=>getReadableStreamFromString,
+    resolveStreamingMode: ()=>resolveStreamingMode
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const external_isbot_namespaceObject = require("isbot");
+const external_common_js_namespaceObject = require("../../../common.js");
+const wrapper_js_namespaceObject = require("../../react/wrapper.js");
+const external_tracer_js_namespaceObject = require("../tracer.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+var shared_ShellChunkStatus = /*#__PURE__*/ function(ShellChunkStatus) {
+    ShellChunkStatus[ShellChunkStatus["START"] = 0] = "START";
+    ShellChunkStatus[ShellChunkStatus["FINISH"] = 1] = "FINISH";
+    return ShellChunkStatus;
+}({});
+const SHOULD_STREAM_ALL_HEADER = 'x-should-stream-all';
+function parseShouldStreamAllFlag(value) {
+    if (!value) return;
+    const normalized = value.trim().toLowerCase();
+    if ('false' === normalized) return false;
+    return true;
+}
+function resolveStreamingMode(request, forceStreamToString) {
+    const shouldStreamAll = parseShouldStreamAllFlag(request.headers.get(SHOULD_STREAM_ALL_HEADER));
+    const isSsgRender = 'true' === request.headers.get('x-modern-ssg-render');
+    const isBot = (0, external_isbot_namespaceObject.isbot)(request.headers.get('user-agent'));
+    if (shouldStreamAll) return {
+        onReady: 'onAllReady',
+        waitForAllReady: true
+    };
+    if (forceStreamToString) return {
+        onReady: 'onAllReady',
+        waitForAllReady: true
+    };
+    if (isBot) return {
+        onReady: 'onAllReady',
+        waitForAllReady: true
+    };
+    if (isSsgRender) return {
+        onReady: 'onAllReady',
+        waitForAllReady: true
+    };
+    return {
+        onReady: 'onShellReady',
+        waitForAllReady: false
+    };
+}
+let encoder;
+function encodeForWebStream(thing) {
+    if (!encoder) encoder = new TextEncoder();
+    if ('string' == typeof thing) return encoder.encode(thing);
+    return thing;
+}
+function getReadableStreamFromString(content) {
+    const readableStream = new ReadableStream({
+        start (controller) {
+            controller.enqueue(encodeForWebStream(content));
+            controller.close();
+        }
+    });
+    return readableStream;
+}
+function createRenderStreaming(createReadableStreamPromise) {
+    return async (request, serverRoot, options)=>{
+        const createReadableStreamFromElement = await createReadableStreamPromise;
+        const end = (0, time_namespaceObject.time)();
+        const { runtimeContext, config, resource } = options;
+        const { onError, onTiming } = options;
+        const { htmlTemplate, entryName } = resource;
+        const ssrConfig = (0, external_utils_js_namespaceObject.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
+        const StreamServerRootWrapper = ({ children })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                children: [
+                    children,
+                    external_common_js_namespaceObject.JSX_SHELL_STREAM_END_MARK
+                ]
+            });
+        let rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+            ssr: true
+        }));
+        rootElement = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StreamServerRootWrapper, {
+            children: rootElement
+        });
+        const stream = await createReadableStreamFromElement(request, rootElement, {
+            config,
+            htmlTemplate,
+            runtimeContext,
+            ssrConfig,
+            entryName,
+            rscClientManifest: options.rscClientManifest,
+            rscSSRManifest: options.rscSSRManifest,
+            rscServerManifest: options.rscServerManifest,
+            rscRoot: options.rscRoot,
+            onShellReady () {
+                const cost = end();
+                onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_SHELL, cost);
+            },
+            onAllReady () {
+                const cost = end();
+                onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
+            },
+            onShellError (error) {
+                onError(error, external_tracer_js_namespaceObject.SSRErrors.RENDER_SHELL);
+            },
+            onError (error) {
+                onError(error, external_tracer_js_namespaceObject.SSRErrors.RENDER_STREAM);
+            }
+        });
+        return stream;
+    };
+}
+exports.ShellChunkStatus = __webpack_exports__.ShellChunkStatus;
+exports.createRenderStreaming = __webpack_exports__.createRenderStreaming;
+exports.encodeForWebStream = __webpack_exports__.encodeForWebStream;
+exports.getReadableStreamFromString = __webpack_exports__.getReadableStreamFromString;
+exports.resolveStreamingMode = __webpack_exports__.resolveStreamingMode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ShellChunkStatus",
+    "createRenderStreaming",
+    "encodeForWebStream",
+    "getReadableStreamFromString",
+    "resolveStreamingMode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,47 @@
+"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__, {
+    getTemplates: ()=>getTemplates
+});
+const external_afterTemplate_js_namespaceObject = require("./afterTemplate.js");
+const external_beforeTemplate_js_namespaceObject = require("./beforeTemplate.js");
+const HTML_SEPARATOR = '<!--<?- html ?>-->';
+const getTemplates = async (htmlTemplate, options)=>{
+    const [beforeAppTemplate = '', afterAppHtmlTemplate = ''] = htmlTemplate.split(HTML_SEPARATOR) || [];
+    const builtBeforeTemplate = await (0, external_beforeTemplate_js_namespaceObject.buildShellBeforeTemplate)(beforeAppTemplate, options);
+    const builtAfterTemplate = await (0, external_afterTemplate_js_namespaceObject.buildShellAfterTemplate)(afterAppHtmlTemplate, options);
+    return {
+        shellBefore: builtBeforeTemplate,
+        shellAfter: builtAfterTemplate
+    };
+};
+exports.getTemplates = __webpack_exports__.getTemplates;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getTemplates"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,149 @@
+"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__, {
+    renderString: ()=>renderString
+});
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const server_namespaceObject = require("react-dom/server");
+var server_default = /*#__PURE__*/ __webpack_require__.n(server_namespaceObject);
+const external_react_helmet_namespaceObject = require("react-helmet");
+var external_react_helmet_default = /*#__PURE__*/ __webpack_require__.n(external_react_helmet_namespaceObject);
+const external_constants_js_namespaceObject = require("../../constants.js");
+const index_js_namespaceObject = require("../../context/index.js");
+const wrapper_js_namespaceObject = require("../../react/wrapper.js");
+const external_constants_js_namespaceObject_1 = require("../constants.js");
+const external_helmet_js_namespaceObject = require("../helmet.js");
+const external_shared_js_namespaceObject = require("../shared.js");
+const external_tracer_js_namespaceObject = require("../tracer.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const external_loadable_js_namespaceObject = require("./loadable.js");
+const external_ssrData_js_namespaceObject = require("./ssrData.js");
+const renderString = async (request, serverRoot, options)=>{
+    const { resource, runtimeContext, config, onError, onTiming } = options;
+    const tracer = {
+        onError,
+        onTiming
+    };
+    const routerContext = runtimeContext.routerContext;
+    const { htmlTemplate, entryName, loadableStats, routeManifest } = resource;
+    const ssrConfig = (0, external_utils_js_namespaceObject.getSSRConfigByEntry)(entryName, config.ssr, config.ssrByEntries);
+    const chunkSet = {
+        renderLevel: external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER,
+        ssrScripts: '',
+        jsChunk: '',
+        cssChunk: ''
+    };
+    const collectors = [
+        new external_loadable_js_namespaceObject.LoadableCollector({
+            stats: loadableStats,
+            nonce: config.nonce,
+            routeManifest,
+            template: htmlTemplate,
+            entryName,
+            chunkSet,
+            config
+        }),
+        new external_ssrData_js_namespaceObject.SSRDataCollector({
+            runtimeContext,
+            request,
+            ssrConfig,
+            ssrContext: runtimeContext.ssrContext,
+            chunkSet,
+            routerContext,
+            nonce: config.nonce,
+            useJsonScript: config.useJsonScript
+        })
+    ];
+    const internalRuntimeContext = (0, index_js_namespaceObject.getGlobalInternalRuntimeContext)();
+    const hooks = internalRuntimeContext.hooks;
+    const extraCollectors = hooks.extendStringSSRCollectors.call({
+        chunkSet
+    });
+    for (const c of extraCollectors)if (c) collectors.unshift(c);
+    const rootElement = (0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(serverRoot, Object.assign(runtimeContext, {
+        ssr: true
+    }));
+    const html = await generateHtml(rootElement, htmlTemplate, chunkSet, collectors, runtimeContext.ssrContext?.htmlModifiers || [], tracer);
+    return html;
+};
+async function generateHtml(App, htmlTemplate, chunkSet, collectors, htmlModifiers, { onError, onTiming }) {
+    let html = '';
+    let helmetData;
+    const finalApp = collectors.reduce((pre, creator)=>creator.collect?.(pre) || pre, App);
+    try {
+        const end = (0, time_namespaceObject.time)();
+        html = server_default().renderToString(finalApp, {
+            identifierPrefix: constants_namespaceObject.SSR_HYDRATION_ID_PREFIX
+        });
+        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER;
+        helmetData = external_react_helmet_default().renderStatic();
+        const cost = end();
+        onTiming(external_tracer_js_namespaceObject.SSRTimings.RENDER_HTML, cost);
+    } catch (e) {
+        chunkSet.renderLevel = external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+        onError(e, external_tracer_js_namespaceObject.SSRErrors.RENDER_HTML);
+    }
+    await Promise.all(collectors.map((component)=>component.effect()));
+    const { ssrScripts, cssChunk, jsChunk } = chunkSet;
+    const finalHtml = await (0, external_shared_js_namespaceObject.buildHtml)(htmlTemplate, [
+        createReplaceHtml(html),
+        createReplaceChunkJs(jsChunk),
+        createReplaceChunkCss(cssChunk),
+        createReplaceSSRDataScript(ssrScripts),
+        (0, external_helmet_js_namespaceObject.createReplaceHelemt)(helmetData),
+        ...htmlModifiers
+    ]);
+    return finalHtml;
+}
+function createReplaceHtml(html) {
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.HTML_PLACEHOLDER, html);
+}
+function createReplaceSSRDataScript(data) {
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.SSR_DATA_PLACEHOLDER, data);
+}
+function createReplaceChunkJs(js) {
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.CHUNK_JS_PLACEHOLDER, js);
+}
+function createReplaceChunkCss(css) {
+    return (template)=>(0, external_utils_js_namespaceObject.safeReplace)(template, external_constants_js_namespaceObject_1.CHUNK_CSS_PLACEHOLDER, css);
+}
+exports.renderString = __webpack_exports__.renderString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderString"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/string/loadable.js

@@ -0,0 +1,146 @@
+"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__, {
+    LoadableCollector: ()=>LoadableCollector
+});
+const server_namespaceObject = require("@loadable/server");
+const external_utils_js_namespaceObject = require("../utils.js");
+const extname = (uri)=>{
+    if ('string' != typeof uri || !uri.includes('.')) return '';
+    return `.${uri?.split('.').pop()}` || '';
+};
+const generateChunks = (chunks, ext)=>chunks.filter((chunk)=>Boolean(chunk.url)).filter((chunk)=>extname(chunk.url).slice(1) === ext);
+const checkIsInline = (chunk, enableInline)=>{
+    if ('production' !== process.env.NODE_ENV) return false;
+    if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
+    return Boolean(enableInline);
+};
+const readAsset = async (chunk)=>{
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const filepath = path.resolve(__dirname, chunk.filename);
+    return fs.readFile(filepath, 'utf-8');
+};
+class LoadableCollector {
+    get existsAssets() {
+        const { routeManifest, entryName } = this.options;
+        return routeManifest?.routeAssets?.[entryName]?.assets;
+    }
+    collect(comopnent) {
+        const { stats, entryName } = this.options;
+        if (!stats) return comopnent;
+        this.extractor = new server_namespaceObject.ChunkExtractor({
+            stats,
+            entrypoints: [
+                entryName
+            ]
+        });
+        return this.extractor.collectChunks(comopnent);
+    }
+    async effect() {
+        if (!this.extractor) return;
+        const { extractor, options } = this;
+        const { entryName, config } = options;
+        const asyncChunks = [];
+        if (config.enableAsyncEntry) try {
+            asyncChunks.push(...extractor.getChunkAssets([
+                `async-${entryName}`
+            ]));
+        } catch (e) {}
+        const chunks = [].concat(asyncChunks).concat(extractor.getChunkAssets(extractor.chunks));
+        const scriptChunks = generateChunks(chunks, 'js');
+        const styleChunks = generateChunks(chunks, 'css');
+        this.emitLoadableScripts(extractor);
+        await this.emitScriptAssets(scriptChunks);
+        await this.emitStyleAssets(styleChunks);
+    }
+    emitLoadableScripts(extractor) {
+        const check = (scripts)=>(scripts || '').includes('__LOADABLE_REQUIRED_CHUNKS___ext');
+        const scripts = extractor.getScriptTags();
+        if (!check(scripts)) return;
+        const { chunkSet } = this.options;
+        const s = scripts.split("<\/script>").slice(0, 2).map((i)=>`${i}</script>`).join('');
+        chunkSet.jsChunk += s;
+    }
+    async emitScriptAssets(chunks) {
+        const { template, nonce, chunkSet, config } = this.options;
+        const { scriptLoading = 'defer', inlineStyles } = config;
+        const scriptLoadingAtr = {
+            defer: 'defer' === scriptLoading ? true : void 0,
+            type: 'module' === scriptLoading ? 'module' : void 0,
+            async: 'async' === scriptLoading ? true : void 0
+        };
+        const attributes = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes({
+            nonce,
+            ...scriptLoadingAtr
+        }));
+        const jsScriptRegExp = /<script .*?src="([^"]+)".*?>/g;
+        const matchs = template.matchAll(jsScriptRegExp);
+        const existedScript = [];
+        for (const match of matchs)existedScript.push(match[1]);
+        const scripts = await Promise.all(chunks.filter((chunk)=>!existedScript.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
+            const script = `<script${attributes} src="${chunk.url}"></script>`;
+            if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<script>${content}</script>`).catch((_)=>script);
+            return script;
+        }));
+        chunkSet.jsChunk += scripts.filter((script)=>Boolean(script)).join('');
+    }
+    async emitStyleAssets(chunks) {
+        const { template, chunkSet, config, entryName } = this.options;
+        const { inlineStyles } = config;
+        const atrributes = (0, external_utils_js_namespaceObject.attributesToString)(this.generateAttributes());
+        const linkRegExp = /<link .*?href="([^"]+)".*?>/g;
+        const matchs = template.matchAll(linkRegExp);
+        const existedLinks = [];
+        for (const match of matchs)existedLinks.push(match[1]);
+        const css = await Promise.all(chunks.filter((chunk)=>!existedLinks.includes(chunk.url) && !this.existsAssets?.includes(chunk.path)).map(async (chunk)=>{
+            const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
+            if ((0, external_utils_js_namespaceObject.checkIsNode)() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
+            return link;
+        }));
+        chunkSet.cssChunk += css.filter((css)=>Boolean(css)).join('');
+    }
+    generateAttributes(extraAtr = {}) {
+        const { config } = this.options;
+        const { crossorigin } = config;
+        const attributes = {};
+        if (crossorigin) attributes.crossorigin = true === crossorigin ? 'anonymous' : crossorigin;
+        return {
+            ...attributes,
+            ...extraAtr
+        };
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+exports.LoadableCollector = __webpack_exports__.LoadableCollector;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LoadableCollector"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/string/ssrData.js

@@ -0,0 +1,151 @@
+"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__, {
+    SSRDataCollector: ()=>SSRDataCollector
+});
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const lifecycle_js_namespaceObject = require("../../../router/runtime/lifecycle.js");
+const external_constants_js_namespaceObject = require("../../constants.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var _options = /*#__PURE__*/ new WeakMap(), _getSSRData = /*#__PURE__*/ new WeakSet(), _getRouterData = /*#__PURE__*/ new WeakSet(), _getSSRDataScripts = /*#__PURE__*/ new WeakSet();
+class SSRDataCollector {
+    effect() {
+        const { chunkSet } = _class_private_field_get(this, _options);
+        const ssrData = _class_private_method_get(this, _getSSRData, getSSRData).call(this);
+        const routerData = _class_private_method_get(this, _getRouterData, getRouterData).call(this);
+        const ssrDataScripts = _class_private_method_get(this, _getSSRDataScripts, getSSRDataScripts).call(this, ssrData, routerData);
+        chunkSet.ssrScripts = ssrDataScripts;
+    }
+    constructor(options){
+        _class_private_method_init(this, _getSSRData);
+        _class_private_method_init(this, _getRouterData);
+        _class_private_method_init(this, _getSSRDataScripts);
+        _class_private_field_init(this, _options, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _options, options);
+    }
+}
+function getSSRData() {
+    const { chunkSet, ssrConfig, ssrContext, runtimeContext } = _class_private_field_get(this, _options);
+    const { reporter, request } = ssrContext;
+    const headers = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
+    return {
+        data: {
+            initialData: runtimeContext.initialData,
+            i18nData: runtimeContext.__i18nData__
+        },
+        context: {
+            request: {
+                params: request.params,
+                query: request.query,
+                pathname: request.pathname,
+                host: request.host,
+                url: request.url,
+                headers: headers
+            },
+            reporter: {
+                sessionId: reporter?.sessionId
+            }
+        },
+        mode: 'string',
+        renderLevel: chunkSet.renderLevel
+    };
+}
+function getRouterData() {
+    const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
+    const snapshotRouterData = runtimeContext.routerServerSnapshot?.routerData;
+    if (snapshotRouterData) return {
+        loaderData: snapshotRouterData.loaderData,
+        errors: (0, external_utils_js_namespaceObject.serializeErrors)(snapshotRouterData.errors || null)
+    };
+    return routerContext ? {
+        loaderData: routerContext.loaderData,
+        errors: (0, external_utils_js_namespaceObject.serializeErrors)(routerContext.errors)
+    } : void 0;
+}
+function getSSRDataScripts(ssrData, routerData) {
+    const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
+    const hydrationScripts = (0, lifecycle_js_namespaceObject.getRouterHydrationScripts)(_class_private_field_get(this, _options).runtimeContext);
+    const serializeSSRData = (0, node_namespaceObject.serializeJson)(ssrData);
+    const attrsStr = (0, external_utils_js_namespaceObject.attributesToString)({
+        nonce
+    });
+    let ssrDataScripts = useJsonScript ? `<script type="application/json" id="${external_constants_js_namespaceObject.SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
+    if (routerData) {
+        const serializedRouterData = (0, node_namespaceObject.serializeJson)(routerData);
+        ssrDataScripts += useJsonScript ? `\n<script type="application/json" id="${external_constants_js_namespaceObject.ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
+    }
+    if (hydrationScripts.length) ssrDataScripts += `\n${hydrationScripts.join('\n')}`;
+    return ssrDataScripts;
+}
+exports.SSRDataCollector = __webpack_exports__.SSRDataCollector;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SSRDataCollector"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/server/string/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});