@bleedingdev/modern-js-runtime 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

package/dist/esm-node/core/server/scriptOrder.mjs

@@ -1,4 +1,7 @@
 import "node:module";
+import { getRouterMatchedRouteIds } from "../../router/runtime/lifecycle.mjs";
+import { CHUNK_JS_PLACEHOLDER } from "./constants.mjs";
+import { safeReplace } from "./utils.mjs";
 function getScriptTags(template) {
     const scriptRegExp = /<script\b[^>]*\bsrc=(["'])(.*?)\1[^>]*><\/script>/g;
     return Array.from(template.matchAll(scriptRegExp)).map((match)=>({
@@ -16,11 +19,67 @@ function isEntryScript(src, entryName, asyncEntry) {
     const prefix = asyncEntry ? `async-${entryName}` : entryName;
     return basename === `${prefix}.js` || basename.startsWith(`${prefix}.`) || basename.startsWith(`${prefix}-`);
 }
+const dedupeByUrl = (chunks)=>{
+    const seen = new Set();
+    return chunks.filter((chunk)=>{
+        if (void 0 === chunk.url || '' === chunk.url || seen.has(chunk.url)) return false;
+        seen.add(chunk.url);
+        return true;
+    });
+};
+const isAsyncEntryScriptChunk = (chunk, entryName)=>{
+    if (void 0 === chunk.url || !chunk.url.endsWith('.js')) return false;
+    const asyncEntryName = `async-${entryName}`;
+    const filename = chunk.filename ?? chunk.url;
+    const basename = filename.split('/').pop() ?? filename;
+    return basename === `${asyncEntryName}.js` || basename.startsWith(`${asyncEntryName}.`) || basename.startsWith(`${asyncEntryName}-`);
+};
+function getRouteAssets(runtimeContext, routeManifest = runtimeContext.routeManifest) {
+    return routeManifest?.routeAssets;
+}
+function getMatchedRouteAssets(runtimeContext, routeManifest) {
+    const routeAssets = getRouteAssets(runtimeContext, routeManifest);
+    if (void 0 === routeAssets) return [];
+    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
+    return matchedRouteIds.flatMap((routeId)=>routeAssets[routeId]?.assets ?? []);
+}
+const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
+    const asyncEntryScriptChunks = [];
+    const asyncEntryDependencyChunks = [];
+    for (const chunk of asyncEntryChunks)if (isAsyncEntryScriptChunk(chunk, entryName)) asyncEntryScriptChunks.push(chunk);
+    else asyncEntryDependencyChunks.push(chunk);
+    return dedupeByUrl([
+        ...asyncEntryDependencyChunks,
+        ...collectedChunks,
+        ...matchedRouteChunks,
+        ...asyncEntryScriptChunks
+    ]);
+};
 function injectBeforeHydrationEntryScript(template, scripts, entryName = 'index') {
-    if (!scripts) return template;
+    if ('' === scripts) return template;
     const scriptTags = getScriptTags(template);
     const target = scriptTags.find((match)=>isEntryScript(match.src, entryName, false)) ?? scriptTags.find((match)=>isEntryScript(match.src, entryName, true));
-    if (!target) return template;
+    if (void 0 === target) return template;
     return `${template.slice(0, target.index)}${scripts}${template.slice(target.index)}`;
 }
-export { injectBeforeHydrationEntryScript };
+function replaceChunkJsPlaceholder(template, scripts, entryName, placeholder = CHUNK_JS_PLACEHOLDER) {
+    if ('' === scripts) return safeReplace(template, placeholder, '');
+    const withoutPlaceholder = safeReplace(template, placeholder, '');
+    const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, scripts, entryName);
+    if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
+    return safeReplace(template, placeholder, scripts);
+}
+function createRouteHydrationScriptTags(runtimeContext, entryName, options = {}) {
+    const { nonce, template } = options;
+    const routeAssets = getRouteAssets(runtimeContext);
+    if (void 0 === routeAssets) return '';
+    const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
+    const assetEntries = [
+        ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
+        routeAssets[`async-${entryName}`]
+    ].filter((entry)=>void 0 !== entry);
+    const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
+    const nonceAttr = void 0 === nonce || '' === nonce ? '' : ` nonce="${nonce}"`;
+    return jsAssets.filter((asset)=>template?.includes(asset) !== true).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
+}
+export { createRouteHydrationScriptTags, getMatchedRouteAssets, injectBeforeHydrationEntryScript, orderHydrationScriptChunks, replaceChunkJsPlaceholder };

package/dist/esm-node/core/server/stream/afterTemplate.mjs

@@ -1,9 +1,9 @@
 import "node:module";
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts, getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
+import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
 import { SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { SSR_DATA_PLACEHOLDER } from "../constants.mjs";
-import { injectBeforeHydrationEntryScript } from "../scriptOrder.mjs";
+import { createRouteHydrationScriptTags, replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
 import { buildHtml } from "../shared.mjs";
 import { attributesToString, safeReplace } from "../utils.mjs";
 function buildShellAfterTemplate(afterAppTemplate, options) {
@@ -20,24 +20,12 @@ function buildShellAfterTemplate(afterAppTemplate, options) {
         (template)=>injectJs(template, entryName, config.nonce)
     ];
     async function injectJs(template, entryName, nonce) {
-        const { routeManifest } = runtimeContext;
-        if (!routeManifest) return template;
-        const { routeAssets } = routeManifest;
-        if (!routeAssets) return template;
-        const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-        const assetEntries = [
-            ...matchedRouteIds.map((routeId)=>routeAssets[routeId]),
-            routeAssets[`async-${entryName}`]
-        ].filter(Boolean);
-        const jsAssets = Array.from(new Set(assetEntries.flatMap((entry)=>(entry.assets ?? []).filter((asset)=>asset.endsWith('.js')))));
-        const nonceAttr = nonce ? ` nonce="${nonce}"` : '';
-        const jsChunkStr = jsAssets.filter((asset)=>!template.includes(asset)).map((asset)=>`<script src=${asset}${nonceAttr}></script>`).join(' ');
-        if (jsChunkStr) {
-            const withoutPlaceholder = safeReplace(template, '<!--<?- chunksMap.js ?>-->', '');
-            const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, jsChunkStr, entryName);
-            return withEarlyScripts !== withoutPlaceholder ? withEarlyScripts : safeReplace(template, '<!--<?- chunksMap.js ?>-->', jsChunkStr);
-        }
-        return template;
+        const jsChunkStr = createRouteHydrationScriptTags(runtimeContext, entryName, {
+            nonce,
+            template
+        });
+        if (!jsChunkStr) return template;
+        return replaceChunkJsPlaceholder(template, jsChunkStr, entryName);
     }
     return buildHtml(afterAppTemplate, callbacks);
 }

package/dist/esm-node/core/server/stream/beforeTemplate.mjs

@@ -5,7 +5,7 @@ import { CHUNK_CSS_PLACEHOLDER } from "../constants.mjs";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
 import { buildHtml } from "../shared.mjs";
-import { checkIsNode, safeReplace } from "../utils.mjs";
+import { checkIsNode, hasStylesheetLink, safeReplace } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var beforeTemplate_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
@@ -49,13 +49,13 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
                     if (!index) return;
                     const routeId = match.route.id;
                     if (routeId) return routeAssets[routeId];
-                }).filter(Boolean) ?? [];
+                }).filter((routeManifest)=>void 0 !== routeManifest) ?? [];
             }
             const asyncEntry = routeAssets[`async-${entryName}`];
             if (asyncEntry) matchedRouteManifests.push(asyncEntry);
             const cssChunks = matchedRouteManifests.reduce((chunks, routeManifest)=>{
                 const { referenceCssAssets = [] } = routeManifest;
-                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !template.includes(asset));
+                const _cssChunks = referenceCssAssets.filter((asset)=>asset?.endsWith('.css') && !hasStylesheetLink(template, asset));
                 return [
                     ...chunks,
                     ..._cssChunks

package/dist/esm-node/core/server/stream/beforeTemplate.worker.mjs

@@ -40,7 +40,7 @@ async function buildShellBeforeTemplate(beforeAppTemplate, options) {
                     if (!index) return;
                     const routeId = match.route.id;
                     if (routeId) return routeAssets[routeId];
-                }).filter(Boolean) ?? [];
+                }).filter((routeManifest)=>void 0 !== routeManifest) ?? [];
             }
             const asyncEntry = routeAssets[`async-${entryName}`];
             if (asyncEntry) matchedRouteManifests.push(asyncEntry);

package/dist/esm-node/core/server/stream/createReadableStream.mjs

@@ -65,12 +65,14 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                             try {
                                 if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                                     chunkVec.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                                    const chunkStr = chunk.toString('utf-8');
-                                    if (chunkStr.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
-                                        let concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
-                                        concatedChunk = concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, '');
+                                    const concatedChunk = Buffer.concat(chunkVec).toString('utf-8');
+                                    const markerIndex = concatedChunk.indexOf(ESCAPED_SHELL_STREAM_END_MARK);
+                                    if (-1 !== markerIndex) {
+                                        const beforeMark = concatedChunk.slice(0, markerIndex);
+                                        const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
                                         shellChunkStatus = ShellChunkStatus.FINISH;
-                                        this.push(`${shellBefore}${concatedChunk}${shellAfter}`);
+                                        this.push(`${shellBefore}${beforeMark}${shellAfter}`);
+                                        if (afterMark) this.push(afterMark);
                                         if (pendingScripts.length > 0) for (const s of pendingScripts)this.push(s);
                                     }
                                 } else this.push(chunk);

package/dist/esm-node/core/server/stream/createReadableStream.worker.mjs

@@ -78,9 +78,13 @@ const createReadableStreamFromElement = async (request, rootElement, options)=>{
                         if (shellChunkStatus !== ShellChunkStatus.FINISH) {
                             chunkVec.push(new TextDecoder().decode(value));
                             const concatedChunk = chunkVec.join('');
-                            if (concatedChunk.includes(ESCAPED_SHELL_STREAM_END_MARK)) {
+                            const markerIndex = concatedChunk.indexOf(ESCAPED_SHELL_STREAM_END_MARK);
+                            if (-1 !== markerIndex) {
+                                const beforeMark = concatedChunk.slice(0, markerIndex);
+                                const afterMark = concatedChunk.slice(markerIndex + ESCAPED_SHELL_STREAM_END_MARK.length);
                                 shellChunkStatus = ShellChunkStatus.FINISH;
-                                safeEnqueue(encodeForWebStream(`${shellBefore}${concatedChunk.replace(ESCAPED_SHELL_STREAM_END_MARK, '')}${shellAfter}`));
+                                safeEnqueue(encodeForWebStream(`${shellBefore}${beforeMark}${shellAfter}`));
+                                if (afterMark.length > 0) safeEnqueue(encodeForWebStream(afterMark));
                                 flushPendingScripts();
                             }
                         } else safeEnqueue(value);

package/dist/esm-node/core/server/stream/deferredScript.mjs

@@ -23,12 +23,15 @@ function isPromiseLike(value) {
     return !!value && 'function' == typeof value.then;
 }
 function toErrorInfo(error) {
+    if ('production' === process.env.NODE_ENV) return {
+        message: 'Unexpected Server 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
+            stack: maybeStack
         };
     }
     return {

package/dist/esm-node/core/server/string/index.mjs

@@ -5,9 +5,9 @@ import server from "react-dom/server";
 import { RenderLevel } from "../../constants.mjs";
 import { getGlobalInternalRuntimeContext } from "../../context/index.mjs";
 import { wrapRuntimeContextProvider } from "../../react/wrapper.mjs";
-import { CHUNK_CSS_PLACEHOLDER, CHUNK_JS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
+import { CHUNK_CSS_PLACEHOLDER, HTML_PLACEHOLDER, SSR_DATA_PLACEHOLDER } from "../constants.mjs";
 import { createReplaceHelemt, getHelmetData } from "../helmet.mjs";
-import { injectBeforeHydrationEntryScript } from "../scriptOrder.mjs";
+import { replaceChunkJsPlaceholder } from "../scriptOrder.mjs";
 import { buildHtml } from "../shared.mjs";
 import { SSRErrors, SSRTimings } from "../tracer.mjs";
 import { getSSRConfigByEntry, safeReplace } from "../utils.mjs";
@@ -99,13 +99,7 @@ function createReplaceSSRDataScript(data) {
     return (template)=>safeReplace(template, SSR_DATA_PLACEHOLDER, data);
 }
 function createReplaceChunkJs(js, entryName) {
-    return (template)=>{
-        if (!js) return safeReplace(template, CHUNK_JS_PLACEHOLDER, '');
-        const withoutPlaceholder = safeReplace(template, CHUNK_JS_PLACEHOLDER, '');
-        const withEarlyScripts = injectBeforeHydrationEntryScript(withoutPlaceholder, js, entryName);
-        if (withEarlyScripts !== withoutPlaceholder) return withEarlyScripts;
-        return safeReplace(template, CHUNK_JS_PLACEHOLDER, js);
-    };
+    return (template)=>replaceChunkJsPlaceholder(template, js, entryName);
 }
 function createReplaceChunkCss(css) {
     return (template)=>safeReplace(template, CHUNK_CSS_PLACEHOLDER, css);

package/dist/esm-node/core/server/string/loadable.mjs

@@ -1,8 +1,8 @@
 import "node:module";
 import { ChunkExtractor } from "@loadable/server";
-import { getRouterMatchedRouteIds } from "../../../router/runtime/lifecycle.mjs";
 import { createFederatedCssLinks } from "../federatedCss.mjs";
-import { attributesToString, checkIsNode } from "../utils.mjs";
+import { getMatchedRouteAssets, orderHydrationScriptChunks } from "../scriptOrder.mjs";
+import { attributesToString, checkIsNode, hasStylesheetLink } from "../utils.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var loadable_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
@@ -11,33 +11,15 @@ const extname = (uri)=>{
     return `.${uri?.split('.').pop()}` || '';
 };
 const generateChunks = (chunks, ext)=>chunks.filter((chunk)=>Boolean(chunk.url)).filter((chunk)=>extname(chunk.url).slice(1) === ext);
-const dedupeChunksByUrl = (chunks)=>{
-    const seen = new Set();
-    return chunks.filter((chunk)=>{
-        if (!chunk.url || seen.has(chunk.url)) return false;
-        seen.add(chunk.url);
-        return true;
+const routeAssetToChunk = (asset)=>({
+        chunk: asset,
+        filename: asset.replace(/^\//, ''),
+        linkType: 'preload',
+        path: asset,
+        scriptType: asset.endsWith('.css') ? 'style' : "script",
+        type: 'routeAsset',
+        url: asset
     });
-};
-const isAsyncEntryScriptChunk = (chunk, entryName)=>{
-    if (!chunk.url?.endsWith('.js')) return false;
-    const asyncEntryName = `async-${entryName}`;
-    const filename = chunk.filename || chunk.url;
-    const basename = filename.split('/').pop() || filename;
-    return basename === `${asyncEntryName}.js` || basename.startsWith(`${asyncEntryName}.`) || basename.startsWith(`${asyncEntryName}-`);
-};
-const orderHydrationScriptChunks = ({ asyncEntryChunks, collectedChunks, matchedRouteChunks, entryName })=>{
-    const asyncEntryScriptChunks = [];
-    const asyncEntryDependencyChunks = [];
-    for (const chunk of asyncEntryChunks)if (isAsyncEntryScriptChunk(chunk, entryName)) asyncEntryScriptChunks.push(chunk);
-    else asyncEntryDependencyChunks.push(chunk);
-    return dedupeChunksByUrl([
-        ...asyncEntryDependencyChunks,
-        ...collectedChunks,
-        ...matchedRouteChunks,
-        ...asyncEntryScriptChunks
-    ]);
-};
 const checkIsInline = (chunk, enableInline)=>{
     if ('production' !== process.env.NODE_ENV) return false;
     if (enableInline instanceof RegExp) return enableInline.test(chunk.url);
@@ -56,17 +38,8 @@ class LoadableCollector {
     }
     getMatchedRouteChunks() {
         const { routeManifest, runtimeContext } = this.options;
-        const routeAssets = routeManifest?.routeAssets;
-        if (!routeAssets) return [];
-        const matchedRouteIds = getRouterMatchedRouteIds(runtimeContext) ?? [];
-        return matchedRouteIds.flatMap((routeId)=>{
-            const routeAsset = routeAssets[routeId];
-            return (routeAsset?.assets ?? []).map((asset)=>({
-                    filename: asset.replace(/^\//, ''),
-                    path: asset,
-                    url: asset
-                }));
-        });
+        if (!routeManifest) return [];
+        return getMatchedRouteAssets(runtimeContext, routeManifest).map(routeAssetToChunk);
     }
     collect(comopnent) {
         const { stats, entryName } = this.options;
@@ -140,11 +113,7 @@ class LoadableCollector {
         const { template, chunkSet, config, moduleFederationCssAssets } = this.options;
         const { inlineStyles } = config;
         const atrributes = 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 emittedChunks = chunks.filter((chunk)=>!existedLinks.includes(chunk.url) && !this.existsAssets?.includes(chunk.path));
+        const emittedChunks = chunks.filter((chunk)=>!hasStylesheetLink(template, chunk.url) && !this.existsAssets?.includes(chunk.path));
         const css = await Promise.all(emittedChunks.map(async (chunk)=>{
             const link = `<link${atrributes} href="${chunk.url}" rel="stylesheet" />`;
             if (checkIsNode() && checkIsInline(chunk, inlineStyles)) return readAsset(chunk).then((content)=>`<style>${content}</style>`).catch((_)=>link);
@@ -154,10 +123,7 @@ class LoadableCollector {
         chunkSet.cssChunk += createFederatedCssLinks(moduleFederationCssAssets, {
             template,
             attributes: this.generateAttributes(),
-            existingAssets: [
-                ...existedLinks,
-                ...emittedChunks.map((chunk)=>chunk.url)
-            ]
+            existingAssets: emittedChunks.map((chunk)=>chunk.url)
         });
     }
     generateAttributes(extraAtr = {}) {

package/dist/esm-node/core/server/string/ssrData.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { serializeJson } from "@modern-js/runtime-utils/node";
-import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
+import { getRouterHydrationScripts, getRouterServerSnapshot } from "../../../router/runtime/lifecycle.mjs";
 import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../../constants.mjs";
 import { attributesToString, serializeErrors } from "../utils.mjs";
 function _check_private_redeclaration(obj, privateCollection) {
@@ -90,7 +90,7 @@ function getSSRData() {
 }
 function getRouterData() {
     const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
-    const snapshotRouterData = runtimeContext.routerServerSnapshot?.routerData;
+    const snapshotRouterData = getRouterServerSnapshot(runtimeContext)?.routerData;
     if (snapshotRouterData) return {
         loaderData: snapshotRouterData.loaderData,
         errors: serializeErrors(snapshotRouterData.errors || null)

package/dist/esm-node/core/server/utils.mjs

@@ -13,17 +13,40 @@ function serializeErrors(errors) {
     if (!errors) return null;
     const entries = Object.entries(errors);
     const serialized = {};
-    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
-        ...val,
-        __type: 'RouteErrorResponse'
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = serializeRouteErrorResponse(val);
+    else if (val instanceof Error) serialized[key] = serializeError(val);
+    else serialized[key] = val;
+    return serialized;
+}
+function shouldRedactServerError() {
+    return 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
+}
+function serializeError(error) {
+    if (shouldRedactServerError()) return {
+        message: 'Unexpected Server Error',
+        stack: void 0,
+        __type: 'Error'
     };
-    else if (val instanceof Error) serialized[key] = {
-        message: val.message,
-        stack: val.stack,
+    return {
+        message: error.message,
+        stack: error.stack,
         __type: 'Error'
     };
-    else serialized[key] = val;
-    return serialized;
+}
+function serializeRouteErrorResponse(error) {
+    if (!isRouteErrorResponse(error)) return error;
+    if (error.status >= 500 && shouldRedactServerError()) return {
+        status: error.status,
+        statusText: 'Internal Server Error',
+        data: 'Unexpected Server Error',
+        __type: 'RouteErrorResponse'
+    };
+    return {
+        status: error.status,
+        statusText: error.statusText,
+        data: error.data,
+        __type: 'RouteErrorResponse'
+    };
 }
 function getSSRConfigByEntry(entryName, ssr, ssrByEntries) {
     if (ssrByEntries?.[entryName]) return ssrByEntries[entryName];
@@ -37,4 +60,24 @@ function getSSRMode(ssrConfig) {
     const result = ssrConfig?.mode === 'string' ? 'string' : 'stream';
     return result;
 }
-export { attributesToString, checkIsNode, getSSRConfigByEntry, getSSRMode, safeReplace, serializeErrors };
+const getLinkAttributes = (linkTag)=>{
+    const attributes = new Map();
+    const attributeRegExp = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    let match;
+    while(match = attributeRegExp.exec(linkTag)){
+        const [, name, doubleQuotedValue, singleQuotedValue, unquotedValue] = match;
+        if ('link' === name.toLowerCase()) continue;
+        attributes.set(name.toLowerCase(), doubleQuotedValue ?? singleQuotedValue ?? unquotedValue ?? '');
+    }
+    return attributes;
+};
+const hasStylesheetLink = (template, href)=>{
+    const linkTags = template.match(/<link\b[^>]*>/gi) ?? [];
+    return linkTags.some((linkTag)=>{
+        const attributes = getLinkAttributes(linkTag);
+        const linkHref = attributes.get('href');
+        const rel = attributes.get('rel');
+        return linkHref === href && rel?.split(/\s+/).some((relToken)=>'stylesheet' === relToken.toLowerCase());
+    });
+};
+export { attributesToString, checkIsNode, getSSRConfigByEntry, getSSRMode, hasStylesheetLink, safeReplace, serializeErrors };

package/dist/esm-node/document/cli/index.mjs

@@ -297,12 +297,13 @@ const documentPlugin = ()=>({
                 processedHtml = processCommentPlaceholders(processedHtml);
                 return `<!DOCTYPE html>${processedHtml}`.replace(DOCUMENT_META_PLACEHOLDER, ()=>metas).replace(DOCUMENT_SSR_PLACEHOLDER, ()=>HTML_SEPARATOR).replace(DOCUMENT_SCRIPTS_PLACEHOLDER, ()=>scripts).replace(DOCUMENT_LINKS_PLACEHOLDER, ()=>links).replace(DOCUMENT_CHUNKSMAP_PLACEHOLDER, ()=>PLACEHOLDER_REPLACER_MAP[DOCUMENT_CHUNKSMAP_PLACEHOLDER]).replace(DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, ()=>PLACEHOLDER_REPLACER_MAP[DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]).replace(DOCUMENT_TITLE_PLACEHOLDER, ()=>titles);
             };
-            const documentEntry = (entryName, templateParameters)=>{
+            const documentEntry = (entryName)=>{
                 const { entrypoints, internalDirectory, appDirectory } = api.getAppContext();
                 const documentFilePath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
                 if (!documentFilePath) return null;
-                return async ({ htmlPlugin })=>{
+                return async (templateData)=>{
                     const config = api.getNormalizedConfig();
+                    const { compilation: _compilation, htmlPlugin, rspackConfig: _rspackConfig, ...templateParameters } = templateData;
                     const documentParams = getDocParams({
                         config: config,
                         entryName,
@@ -320,6 +321,7 @@ const documentPlugin = ()=>({
                     debug("entry %s's document jsx rendered html: %o", entryName, html);
                     const { partialsByEntrypoint } = api.getAppContext();
                     html = processPartials(html, entryName, partialsByEntrypoint || {});
+                    if (!htmlPlugin) throw new Error('Failed to get HTML plugin tags from template parameters.');
                     const { scripts, links, metas, titles } = extractHtmlTags(htmlPlugin, templateParameters);
                     return processPlaceholders(html, config, scripts, links, metas, titles);
                 };
@@ -330,10 +332,7 @@ const documentPlugin = ()=>({
                 return {
                     tools: {
                         htmlPlugin: (options, entry)=>{
-                            const hackParameters = 'function' == typeof options?.templateParameters ? options?.templateParameters({}, {}, {}, {}) : {
-                                ...options?.templateParameters
-                            };
-                            const templateContent = documentEntry(entry.entryName, hackParameters);
+                            const templateContent = documentEntry(entry.entryName);
                             const documentHtmlOptions = templateContent ? {
                                 templateContent,
                                 inject: false