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

package/dist/esm-node/document/Html.mjs

@@ -0,0 +1,87 @@
+import "node:module";
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { Body } from "./Body.mjs";
+import { DocumentStructureContext } from "./DocumentStructureContext.mjs";
+import { Head } from "./Head.mjs";
+import { Links } from "./Links.mjs";
+import { Root } from "./Root.mjs";
+import { Scripts } from "./Scripts.mjs";
+function findTargetChildByName(tag, children) {
+    return children.find((item)=>getEleType(item) === tag);
+}
+function findTargetChildByComponent(component, children) {
+    return children.find((item)=>item?.type === component);
+}
+function findTargetElementByComponent(component, children) {
+    if (0 === children.length) return null;
+    let nextChildren = [];
+    for (const item of children){
+        if (item?.type === component) return item;
+        if (item?.props?.children) nextChildren = nextChildren.concat(item.props.children);
+    }
+    return findTargetElementByComponent(component, nextChildren);
+}
+function getEleType(ele) {
+    return 'function' == typeof ele?.type ? ele.type.name : ele?.type;
+}
+function findTargetElement(tag, children) {
+    if (0 === children.length) return null;
+    let nextChildren = [];
+    for (const item of children){
+        if (tag === getEleType(item)) return item;
+        if (item?.props?.children) nextChildren = nextChildren.concat(item.props.children);
+    }
+    return findTargetElement(tag, nextChildren);
+}
+function Html(props) {
+    const { children, ...rest } = props;
+    const hasSetHead = Boolean(findTargetChildByComponent(Head, children) || findTargetChildByName('Head', children));
+    const hasSetScripts = Boolean(findTargetElementByComponent(Scripts, children) || findTargetChildByName('Scripts', children));
+    const hasSetLinks = Boolean(findTargetElementByComponent(Links, children) || findTargetChildByName('Links', children));
+    const hasSetBody = Boolean(findTargetElementByComponent(Body, children) || findTargetChildByName('Body', children));
+    const hasSetRoot = Boolean(findTargetElementByComponent(Root, children) || findTargetChildByName('Root', children));
+    const hasSetTitle = Boolean(findTargetElement('title', children));
+    const notMissMustChild = [
+        hasSetHead,
+        hasSetBody
+    ].every((item)=>item);
+    if (!notMissMustChild) return /*#__PURE__*/ jsx("html", {
+        children: /*#__PURE__*/ jsxs("body", {
+            style: {
+                color: 'red'
+            },
+            children: [
+                "Miss the ",
+                [
+                    hasSetHead,
+                    hasSetBody
+                ].map((item, index)=>item ? null : [
+                        'Head',
+                        'Body'
+                    ][index]),
+                " Element"
+            ]
+        })
+    });
+    return /*#__PURE__*/ jsx("html", {
+        ...rest,
+        children: /*#__PURE__*/ jsxs(DocumentStructureContext.Provider, {
+            value: {
+                hasSetHead,
+                hasSetScripts,
+                hasSetLinks,
+                hasSetRoot,
+                hasSetBody,
+                hasSetTitle,
+                docChild: children
+            },
+            children: [
+                !hasSetHead && /*#__PURE__*/ jsx(Head, {}),
+                !hasSetBody && /*#__PURE__*/ jsx(Body, {}),
+                children
+            ]
+        })
+    });
+}
+export { Html };

package/dist/esm-node/document/Links.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_LINKS_PLACEHOLDER } from "./constants.mjs";
+function Links() {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: DOCUMENT_LINKS_PLACEHOLDER
+    });
+}
+export { Links };

package/dist/esm-node/document/Root.mjs

@@ -0,0 +1,30 @@
+import "node:module";
+import { jsxs } from "react/jsx-runtime";
+import { omit } from "@modern-js/utils/lodash";
+import { useContext } from "react";
+import { DOCUMENT_SSR_PLACEHOLDER } from "./constants.mjs";
+import { DocumentContext } from "./DocumentContext.mjs";
+function Root(props) {
+    const { rootId, children, ...rest } = props;
+    const legalProperties = omit(rest, 'id');
+    const { templateParams: { mountId = 'root' } } = useContext(DocumentContext);
+    return /*#__PURE__*/ jsxs("div", {
+        id: `${rootId || mountId}`,
+        ...legalProperties,
+        children: [
+            `${DOCUMENT_SSR_PLACEHOLDER}`,
+            children
+        ]
+    });
+}
+function DefaultRoot(props) {
+    const { templateParams: { mountId = 'root' } } = useContext(DocumentContext);
+    return /*#__PURE__*/ jsxs("div", {
+        id: `${mountId}`,
+        children: [
+            `${DOCUMENT_SSR_PLACEHOLDER}`,
+            props.children
+        ]
+    });
+}
+export { DefaultRoot, Root };

package/dist/esm-node/document/Script.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { renderToString } from "react-dom/server";
+import { DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START } from "./constants.mjs";
+function Script(props) {
+    const { content, ...rests } = props;
+    const contentStr = content?.toString();
+    const contentIIFE = contentStr?.length ? encodeURIComponent(`(${contentStr})()`) : '';
+    const scriptProperties = renderToString(/*#__PURE__*/ jsx("script", {
+        ...rests
+    }));
+    const scriptpPropertiesStr = encodeURIComponent(scriptProperties.replace("<script ", '').replace("><\/script>", ''));
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_SCRIPT_PLACEHOLDER_START}`,
+            `${DOCUMENT_SCRIPT_ATTRIBUTES_START}${scriptpPropertiesStr}${DOCUMENT_SCRIPT_ATTRIBUTES_END}`,
+            `${contentIIFE}`,
+            `${DOCUMENT_SCRIPT_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Script };

package/dist/esm-node/document/Scripts.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_SCRIPTS_PLACEHOLDER } from "./constants.mjs";
+function Scripts() {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: `${DOCUMENT_SCRIPTS_PLACEHOLDER}`
+    });
+}
+export { Scripts };

package/dist/esm-node/document/Style.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+import { Fragment, jsxs } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START } from "./constants.mjs";
+function Style(props) {
+    const { content, children } = props;
+    const contentStr = children || content;
+    const styleContent = encodeURIComponent(`${contentStr}`);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_STYLE_PLACEHOLDER_START}`,
+            `${styleContent}`,
+            `${DOCUMENT_STYLE_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Style };

package/dist/esm-node/document/Title.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { DOCUMENT_TITLE_PLACEHOLDER } from "./constants.mjs";
+function Title() {
+    return /*#__PURE__*/ jsx("title", {
+        children: DOCUMENT_TITLE_PLACEHOLDER
+    });
+}
+export { Title };

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

@@ -0,0 +1,353 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { createDebugger, findExists, fs, logger } from "@modern-js/utils";
+import { decodeHTML } from "entities";
+import module_0, { builtinModules } from "module";
+import path from "path";
+import { BODY_PARTICALS_SEPARATOR, DOCUMENT_CHUNKSMAP_PLACEHOLDER, DOCUMENT_COMMENT_PLACEHOLDER_END, DOCUMENT_COMMENT_PLACEHOLDER_START, DOCUMENT_FILE_NAME, DOCUMENT_LINKS_PLACEHOLDER, DOCUMENT_META_PLACEHOLDER, DOCUMENT_SCRIPTS_PLACEHOLDER, DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START, DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, DOCUMENT_SSR_PLACEHOLDER, DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START, DOCUMENT_TITLE_PLACEHOLDER, DOC_EXT, HEAD_PARTICALS_SEPARATOR, HTML_SEPARATOR, PLACEHOLDER_REPLACER_MAP, TOP_PARTICALS_SEPARATOR } from "../constants.mjs";
+const debug = createDebugger('document');
+const entryName2DocCode = new Map();
+const CONSTANTS = {
+    GLOBAL_DOC_RENDERERS: '__MODERN_DOC_RENDERERS__',
+    DOCUMENT_OUTPUT_DIR: 'document',
+    TEMP_ENTRY_PREFIX: '_entry_',
+    HTML_OUTPUT_PREFIX: '_',
+    HTML_OUTPUT_SUFFIX: '.html.js',
+    CHILD_COMPILER_PREFIX: 'modernjs-document-',
+    COMMONJS_EXTERNAL_PREFIX: 'commonjs ',
+    NODE_PREFIX: 'node:'
+};
+const EXTERNAL_MAPPINGS = {
+    react: 'react',
+    'react/jsx-runtime': 'react/jsx-runtime',
+    'react/jsx-dev-runtime': 'react/jsx-dev-runtime',
+    'react-dom/server': 'react-dom/server'
+};
+const getGlobalDocRenderers = ()=>{
+    const g = globalThis;
+    g[CONSTANTS.GLOBAL_DOC_RENDERERS] = g[CONSTANTS.GLOBAL_DOC_RENDERERS] || {};
+    return g[CONSTANTS.GLOBAL_DOC_RENDERERS];
+};
+const clearGlobalDocRenderer = (entryName)=>{
+    const renderers = getGlobalDocRenderers();
+    if (renderers[entryName]) delete renderers[entryName];
+};
+const decodeHtmlEntities = (input)=>decodeHTML(input);
+const isWindowsAbs = (req)=>/^[a-zA-Z]:[\\/]/.test(req);
+const isRelativeOrAbs = (req)=>req.startsWith('.') || req.startsWith('/') || isWindowsAbs(req);
+const isAsset = (req)=>/\.(css|less|scss|sass|styl|png|jpe?g|gif|svg|ico|woff2?|ttf|eot)(?:[?#].*)?$/.test(req);
+const processScriptPlaceholders = (html, nonce)=>{
+    if (!html.includes(DOCUMENT_SCRIPT_PLACEHOLDER_START) || !html.includes(DOCUMENT_SCRIPT_PLACEHOLDER_END)) return html;
+    const nonceAttr = nonce ? `nonce="${nonce}"` : '';
+    return html.replace(new RegExp(`${DOCUMENT_SCRIPT_PLACEHOLDER_START}${DOCUMENT_SCRIPT_ATTRIBUTES_START}([\\s\\S]*?)${DOCUMENT_SCRIPT_ATTRIBUTES_END}([\\s\\S]*?)${DOCUMENT_SCRIPT_PLACEHOLDER_END}`, 'g'), (_scriptStr, $1, $2)=>`<script ${decodeURIComponent($1)} ${nonceAttr}>${decodeHtmlEntities(decodeURIComponent($2))}</script>`);
+};
+const processStylePlaceholders = (html)=>{
+    if (!html.includes(DOCUMENT_STYLE_PLACEHOLDER_START) || !html.includes(DOCUMENT_STYLE_PLACEHOLDER_END)) return html;
+    return html.replace(new RegExp(`${DOCUMENT_STYLE_PLACEHOLDER_START}([\\s\\S]*?)${DOCUMENT_STYLE_PLACEHOLDER_END}`, 'g'), (_styleStr, $1)=>`<style>${decodeHtmlEntities(decodeURIComponent($1))}</style>`);
+};
+const processCommentPlaceholders = (html)=>{
+    if (!html.includes(DOCUMENT_COMMENT_PLACEHOLDER_START) || !html.includes(DOCUMENT_COMMENT_PLACEHOLDER_END)) return html;
+    return html.replace(new RegExp(`${DOCUMENT_COMMENT_PLACEHOLDER_START}([\\s\\S]*?)${DOCUMENT_COMMENT_PLACEHOLDER_END}`, 'g'), (_scriptStr, $1)=>`${decodeHtmlEntities(decodeURIComponent($1))}`);
+};
+const requireFromString = (code, filename)=>{
+    const m = new module_0.Module(filename, module.parent);
+    m.filename = filename;
+    m.paths = module_0.Module._nodeModulePaths(path.dirname(filename));
+    m._compile(code, filename);
+    return m.exports;
+};
+const getDocumentByEntryName = function(entrypoints, entryName, fallbackDir) {
+    const entryDir = entrypoints.find((item)=>item.entryName === entryName)?.absoluteEntryDir;
+    const entryDirs = DOC_EXT.map((item)=>`${entryDir}${path.sep}${DOCUMENT_FILE_NAME}.${item}`);
+    const fallbackDirs = fallbackDir ? DOC_EXT.map((item)=>[
+            fallbackDir,
+            'src',
+            `${DOCUMENT_FILE_NAME}.${item}`
+        ].join(path.sep)) : [];
+    const docFile = findExists([
+        ...entryDirs,
+        ...fallbackDirs
+    ]);
+    return docFile || void 0;
+};
+const createExternalHandler = ()=>({ request })=>{
+        const req = request || '';
+        if (isAsset(req)) return;
+        if (req.startsWith(CONSTANTS.NODE_PREFIX)) return `${CONSTANTS.COMMONJS_EXTERNAL_PREFIX}${req}`;
+        if (builtinModules.includes(req)) return `${CONSTANTS.COMMONJS_EXTERNAL_PREFIX}${req}`;
+        isRelativeOrAbs(req);
+    };
+const configureChildCompiler = (child, compiler, appDirectory)=>{
+    child.options.mode = compiler.options.mode;
+    child.options.target = 'node';
+    child.options.context = compiler.options.context || appDirectory;
+    child.options.resolve = {
+        ...compiler.options.resolve,
+        fallback: {}
+    };
+    child.options.module = compiler.options.module;
+    child.options.externalsPresets = {
+        node: true
+    };
+    child.options.devtool = false;
+    if (child.options.optimization && 'object' == typeof child.options.optimization) child.options.optimization.minimize = false;
+    else child.options.optimization = {
+        minimize: false
+    };
+};
+const applyExternalsPlugin = (child, compiler)=>{
+    const ExternalsPlugin = compiler.rspack?.ExternalsPlugin;
+    if (ExternalsPlugin) new ExternalsPlugin('commonjs', [
+        createExternalHandler(),
+        EXTERNAL_MAPPINGS
+    ]).apply(child);
+};
+const generateEntryCode = (docPath, _entryName)=>{
+    const runtimeAPI = require.resolve('../');
+    const esmRuntimeAPI = runtimeAPI.replace("cjs", "esm").replace(/.js$/, '.mjs');
+    return `import React from 'react';
+import ReactDomServer from 'react-dom/server';
+import Document from ${JSON.stringify(docPath)};
+import { DocumentContext } from ${JSON.stringify(esmRuntimeAPI)};
+
+// expose to global for host to consume
+var g = (typeof globalThis !== 'undefined' ? globalThis : global);
+g.__MODERN_DOC_RENDERERS__ = g.__MODERN_DOC_RENDERERS__ || {};
+
+function render(documentParams) {
+  var HTMLElement = React.createElement(
+    DocumentContext.Provider,
+    { value: documentParams },
+    React.createElement(Document, null)
+  );
+  return ReactDomServer.renderToStaticMarkup(HTMLElement);
+}
+
+g.__MODERN_DOC_RENDERERS__[${JSON.stringify(_entryName)}] = render;
+
+export default { render: render };`;
+};
+const processChildCompilation = async (entryName, docPath, compilation, compiler, appDirectory, internalDirectory)=>new Promise((resolve, reject)=>{
+        const outFile = path.posix.join(CONSTANTS.DOCUMENT_OUTPUT_DIR, `${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
+        const child = compilation.createChildCompiler(`${CONSTANTS.CHILD_COMPILER_PREFIX}${entryName}`, {
+            filename: outFile,
+            library: {
+                type: 'commonjs2'
+            }
+        }, []);
+        configureChildCompiler(child, compiler, appDirectory);
+        applyExternalsPlugin(child, compiler);
+        const entryDir = path.join(internalDirectory, CONSTANTS.DOCUMENT_OUTPUT_DIR);
+        const tempEntry = path.join(entryDir, `${CONSTANTS.TEMP_ENTRY_PREFIX}${entryName}.js`);
+        const finalize = ()=>{
+            try {
+                const EntryPlugin = compiler.rspack?.EntryPlugin;
+                if (!EntryPlugin) throw new Error('EntryPlugin not available');
+                new EntryPlugin(compiler.context, tempEntry, {
+                    name: `${CONSTANTS.CHILD_COMPILER_PREFIX}${entryName}`
+                }).apply(child);
+                child.runAsChild((err, _entries, childCompilation)=>{
+                    if (err) {
+                        logger.error(`Document child compiler failed for entry "${entryName}": ${err.message}`);
+                        return reject(err);
+                    }
+                    try {
+                        if (!childCompilation) throw new Error('Child compilation is undefined');
+                        const asset = childCompilation.assets[outFile] || childCompilation.getAsset?.(outFile)?.source;
+                        const code = 'function' == typeof asset?.source ? asset.source().toString() : 'string' == typeof asset ? asset : asset?.buffer?.().toString?.() || '';
+                        if (!code) {
+                            const errorMsg = `Document child compiler produced empty output for entry "${entryName}". Please check your Document component for syntax errors.`;
+                            logger.error(errorMsg);
+                            reject(new Error(errorMsg));
+                            return;
+                        }
+                        entryName2DocCode.set(entryName, code);
+                        debug('Document child compiler: cached injected bundle for %s', entryName);
+                        resolve();
+                    } catch (e) {
+                        const err = e;
+                        logger.error(`Document child compiler failed to process output for entry "${entryName}": ${err.message}`);
+                        reject(err);
+                    }
+                });
+            } catch (e) {
+                const err = e;
+                logger.error(`Document child compiler failed to initialize for entry "${entryName}": ${err.message}`);
+                reject(err);
+            }
+        };
+        try {
+            fs.ensureFile(tempEntry).then(()=>{
+                const entryCode = generateEntryCode(docPath, entryName);
+                return fs.writeFile(tempEntry, entryCode);
+            }).then(finalize).catch((e)=>{
+                const err = e;
+                logger.error(`Document child compiler failed to prepare entry file for "${entryName}": ${err.message}`);
+                reject(err);
+            });
+        } catch (e) {
+            const err = e;
+            logger.error(`Document child compiler failed to create entry directory for "${entryName}": ${err.message}`);
+            reject(err);
+        }
+    });
+const documentPlugin = ()=>({
+        name: '@modern-js/plugin-document',
+        pre: [
+            '@modern-js/plugin-analyze'
+        ],
+        setup: async (api)=>{
+            class ModernJsDocumentChildCompilerPlugin {
+                apply(compiler) {
+                    compiler.hooks.make.tapPromise(this.name, async (compilation)=>{
+                        try {
+                            const { entrypoints, appDirectory, internalDirectory } = api.getAppContext();
+                            const tasks = [];
+                            for (const ep of entrypoints || []){
+                                const entryName = ep.entryName;
+                                const docPath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
+                                if (docPath) {
+                                    compilation.fileDependencies?.add?.(docPath);
+                                    clearGlobalDocRenderer(entryName);
+                                    tasks.push(processChildCompilation(entryName, docPath, compilation, compiler, appDirectory, internalDirectory));
+                                }
+                            }
+                            await Promise.all(tasks);
+                        } catch (e) {
+                            const err = e;
+                            logger.error(`Document child compiler failed: ${err.message}`);
+                            debug('Document child compiler make hook failed: %o', e);
+                            throw err;
+                        }
+                    });
+                }
+                constructor(){
+                    this.name = 'ModernJsDocumentChildCompilerPlugin';
+                }
+            }
+            api.config(()=>({
+                    tools: {
+                        bundlerChain: (chain)=>{
+                            chain.plugin('modernjs-document-child-compiler').use(ModernJsDocumentChildCompilerPlugin, []);
+                        }
+                    }
+                }));
+            const getDocParams = (params)=>{
+                const { config, templateParameters, entryName } = params;
+                return {
+                    processEnv: process.env,
+                    config: {
+                        output: config.output
+                    },
+                    entryName,
+                    templateParams: templateParameters
+                };
+            };
+            const loadRender = async (entryName, internalDirectory)=>{
+                const renderers = getGlobalDocRenderers();
+                const globalRenderer = renderers[entryName];
+                if (globalRenderer) return {
+                    renderer: globalRenderer
+                };
+                const cached = entryName2DocCode.get(entryName);
+                if (!cached) throw new Error(`Document bundle not found for entry "${entryName}". The Document component compilation may have failed.`);
+                const filename = path.join(internalDirectory, `./${CONSTANTS.DOCUMENT_OUTPUT_DIR}/${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
+                requireFromString(cached, filename);
+                const renderer = renderers[entryName];
+                if (!renderer) throw new Error(`Document renderer not found for entry "${entryName}". Please ensure your Document component exports a valid default component.`);
+                return {
+                    renderer
+                };
+            };
+            const processPartials = (html, entryName, partialsByEntrypoint)=>{
+                const partialsContent = {
+                    partialsTop: '',
+                    partialsHead: '',
+                    partialsBody: ''
+                };
+                if (partialsByEntrypoint?.[entryName]) {
+                    partialsContent.partialsTop = partialsByEntrypoint[entryName].top.join('\n');
+                    partialsContent.partialsHead = partialsByEntrypoint[entryName].head.join('\n');
+                    partialsContent.partialsBody = partialsByEntrypoint[entryName].body.join('\n');
+                }
+                return html.replace(TOP_PARTICALS_SEPARATOR, ()=>partialsContent.partialsTop).replace(HEAD_PARTICALS_SEPARATOR, ()=>partialsContent.partialsHead).replace(BODY_PARTICALS_SEPARATOR, ()=>partialsContent.partialsBody);
+            };
+            const extractHtmlTags = (htmlPlugin, templateParameters)=>{
+                const scripts = [
+                    htmlPlugin.tags.headTags.filter((item)=>"script" === item.tagName).join(''),
+                    htmlPlugin.tags.bodyTags.toString()
+                ].join('');
+                const links = htmlPlugin.tags.headTags.filter((item)=>'link' === item.tagName).join('');
+                const metas = [
+                    templateParameters.meta,
+                    htmlPlugin.tags.headTags.filter((item)=>"script" !== item.tagName && 'link' !== item.tagName && 'title' !== item.tagName).join('')
+                ].join('');
+                const titles = htmlPlugin.tags.headTags.filter((item)=>'title' === item.tagName).join('').replace('<title>', '').replace('</title>', '');
+                return {
+                    scripts,
+                    links,
+                    metas,
+                    titles
+                };
+            };
+            const processPlaceholders = (html, config, scripts, links, metas, titles)=>{
+                const { nonce } = config.security || {};
+                let processedHtml = processScriptPlaceholders(html, nonce);
+                processedHtml = processStylePlaceholders(processedHtml);
+                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 { entrypoints, internalDirectory, appDirectory } = api.getAppContext();
+                const documentFilePath = getDocumentByEntryName(entrypoints, entryName, appDirectory);
+                if (!documentFilePath) return null;
+                return async ({ htmlPlugin })=>{
+                    const config = api.getNormalizedConfig();
+                    const documentParams = getDocParams({
+                        config: config,
+                        entryName,
+                        templateParameters
+                    });
+                    let html;
+                    try {
+                        const { renderer } = await loadRender(entryName, internalDirectory);
+                        html = renderer(documentParams);
+                    } catch (error) {
+                        const err = error;
+                        logger.error(`Failed to render Document for entry "${entryName}": ${err.message}`);
+                        throw err;
+                    }
+                    debug("entry %s's document jsx rendered html: %o", entryName, html);
+                    const { partialsByEntrypoint } = api.getAppContext();
+                    html = processPartials(html, entryName, partialsByEntrypoint || {});
+                    const { scripts, links, metas, titles } = extractHtmlTags(htmlPlugin, templateParameters);
+                    return processPlaceholders(html, config, scripts, links, metas, titles);
+                };
+            };
+            api.config(()=>{
+                const userConfig = api.getConfig();
+                if (userConfig.tools?.htmlPlugin === false) return {};
+                return {
+                    tools: {
+                        htmlPlugin: (options, entry)=>{
+                            const hackParameters = 'function' == typeof options?.templateParameters ? options?.templateParameters({}, {}, {}, {}) : {
+                                ...options?.templateParameters
+                            };
+                            const templateContent = documentEntry(entry.entryName, hackParameters);
+                            const documentHtmlOptions = templateContent ? {
+                                templateContent,
+                                inject: false
+                            } : {};
+                            return {
+                                ...options,
+                                ...documentHtmlOptions
+                            };
+                        }
+                    }
+                };
+            });
+        }
+    });
+const cli = documentPlugin;
+export default cli;
+export { documentPlugin, getDocumentByEntryName };

package/dist/esm-node/document/constants.mjs

@@ -0,0 +1,35 @@
+import "node:module";
+import { HTML_CHUNKSMAP_SEPARATOR } from "@modern-js/utils/universal/constants";
+const DOC_EXT = [
+    'jsx',
+    'tsx',
+    'ts',
+    'js'
+];
+const DOCUMENT_META_PLACEHOLDER = encodeURIComponent('<%= meta %>');
+const DOCUMENT_TITLE_PLACEHOLDER = encodeURIComponent('<%= title %>');
+const HTML_SEPARATOR = '<!--<?- html ?>-->';
+const HEAD_PARTICALS_SEPARATOR = encodeURIComponent('<!--<?- partials.head ?>-->');
+const BODY_PARTICALS_SEPARATOR = encodeURIComponent('<!--<?- partials.body ?>-->');
+const TOP_PARTICALS_SEPARATOR = encodeURIComponent('<!--<?- partials.top ?>-->');
+const HTML_SSRDATASCRIPT_SEPARATOR = '<!--<?- SSRDataScript ?>-->';
+const DOCUMENT_SSR_PLACEHOLDER = encodeURIComponent(HTML_SEPARATOR);
+const DOCUMENT_CHUNKSMAP_PLACEHOLDER = encodeURIComponent(HTML_CHUNKSMAP_SEPARATOR);
+const DOCUMENT_SSRDATASCRIPT_PLACEHOLDER = encodeURIComponent(HTML_SSRDATASCRIPT_SEPARATOR);
+const DOCUMENT_FILE_NAME = 'Document';
+const DOCUMENT_SCRIPTS_PLACEHOLDER = encodeURIComponent("\x3c!-- chunk scripts placeholder --\x3e");
+const DOCUMENT_LINKS_PLACEHOLDER = encodeURIComponent('<!-- chunk links placeholder -->');
+const DOCUMENT_SCRIPT_PLACEHOLDER_START = encodeURIComponent("\x3c!-- script-start --\x3e");
+const DOCUMENT_SCRIPT_PLACEHOLDER_END = encodeURIComponent("\x3c!-- script-end --\x3e");
+const DOCUMENT_SCRIPT_ATTRIBUTES_START = encodeURIComponent("\x3c!-- script-scriptpProperties-start --\x3e");
+const DOCUMENT_SCRIPT_ATTRIBUTES_END = encodeURIComponent("\x3c!-- script-scriptpProperties-end --\x3e");
+const DOCUMENT_STYLE_PLACEHOLDER_START = encodeURIComponent('<!-- style-start -->');
+const DOCUMENT_STYLE_PLACEHOLDER_END = encodeURIComponent('<!-- style-end -->');
+const DOCUMENT_COMMENT_PLACEHOLDER_START = encodeURIComponent('<!-- comment-start -->');
+const DOCUMENT_COMMENT_PLACEHOLDER_END = encodeURIComponent('<!-- comment-end -->');
+const PLACEHOLDER_REPLACER_MAP = {
+    [DOCUMENT_SSR_PLACEHOLDER]: HTML_SEPARATOR,
+    [DOCUMENT_CHUNKSMAP_PLACEHOLDER]: HTML_CHUNKSMAP_SEPARATOR,
+    [DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]: HTML_SSRDATASCRIPT_SEPARATOR
+};
+export { BODY_PARTICALS_SEPARATOR, DOCUMENT_CHUNKSMAP_PLACEHOLDER, DOCUMENT_COMMENT_PLACEHOLDER_END, DOCUMENT_COMMENT_PLACEHOLDER_START, DOCUMENT_FILE_NAME, DOCUMENT_LINKS_PLACEHOLDER, DOCUMENT_META_PLACEHOLDER, DOCUMENT_SCRIPTS_PLACEHOLDER, DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START, DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, DOCUMENT_SSR_PLACEHOLDER, DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START, DOCUMENT_TITLE_PLACEHOLDER, DOC_EXT, HEAD_PARTICALS_SEPARATOR, HTML_SEPARATOR, HTML_SSRDATASCRIPT_SEPARATOR, PLACEHOLDER_REPLACER_MAP, TOP_PARTICALS_SEPARATOR };

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

@@ -0,0 +1,13 @@
+import "node:module";
+export * from "./Body.mjs";
+export * from "./Comment.mjs";
+export * from "./constants.mjs";
+export * from "./DocumentContext.mjs";
+export * from "./DocumentStructureContext.mjs";
+export * from "./Head.mjs";
+export * from "./Html.mjs";
+export * from "./Links.mjs";
+export * from "./Root.mjs";
+export * from "./Script.mjs";
+export * from "./Scripts.mjs";
+export * from "./Style.mjs";

package/dist/esm-node/exports/config-routes.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+function defineRoutes(routesCallback) {
+    return routesCallback;
+}
+export { defineRoutes };

package/dist/esm-node/exports/head.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+"use client";
+import react_helmet, { Helmet } from "react-helmet";
+const head = react_helmet;
+export default head;
+export { Helmet };

package/dist/esm-node/exports/loadable.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+import component from "@loadable/component";
+export * from "@loadable/component";
+const loadable = component;
+export default loadable;

package/dist/esm-node/exports/tanstack-router.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export * from "@tanstack/react-router";
+export { Form, RouteActionResponseError, useFetcher } from "../router/runtime/tanstack/dataMutation.mjs";
+export { Link, NavLink } from "../router/runtime/tanstack/prefetchLink.mjs";

package/dist/esm-node/index.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+export { isBrowser } from "./common.mjs";
+export { RuntimeContext, defineRuntimeConfig, useRuntimeContext } from "./core/index.mjs";
+export { getMonitors } from "./core/context/monitors/index.mjs";
+export { getRequest } from "./core/context/request/index.mjs";
+export { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";

package/dist/esm-node/internal.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { InternalRuntimeContext } from "./core/context/runtime.mjs";

package/dist/esm-node/react-server.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { getMonitors } from "./core/context/monitors/index.mjs";
+export { getRequest } from "./core/context/request/index.mjs";
+export { redirect, setHeaders, setStatus } from "./core/context/response/index.mjs";