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

package/dist/cjs/document/Script.js

@@ -0,0 +1,55 @@
+"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__, {
+    Script: ()=>Script
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const server_namespaceObject = require("react-dom/server");
+const external_constants_js_namespaceObject = require("./constants.js");
+function Script(props) {
+    const { content, ...rests } = props;
+    const contentStr = content?.toString();
+    const contentIIFE = contentStr?.length ? encodeURIComponent(`(${contentStr})()`) : '';
+    const scriptProperties = (0, server_namespaceObject.renderToString)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("script", {
+        ...rests
+    }));
+    const scriptpPropertiesStr = encodeURIComponent(scriptProperties.replace("<script ", '').replace("><\/script>", ''));
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            `${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_PLACEHOLDER_START}`,
+            `${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_ATTRIBUTES_START}${scriptpPropertiesStr}${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_ATTRIBUTES_END}`,
+            `${contentIIFE}`,
+            `${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_PLACEHOLDER_END}`
+        ]
+    });
+}
+exports.Script = __webpack_exports__.Script;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Script"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/document/Scripts.js

@@ -0,0 +1,43 @@
+"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__, {
+    Scripts: ()=>Scripts
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const external_constants_js_namespaceObject = require("./constants.js");
+function Scripts() {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: `${external_constants_js_namespaceObject.DOCUMENT_SCRIPTS_PLACEHOLDER}`
+    });
+}
+exports.Scripts = __webpack_exports__.Scripts;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Scripts"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/document/Style.js

@@ -0,0 +1,50 @@
+"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__, {
+    Style: ()=>Style
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const external_constants_js_namespaceObject = require("./constants.js");
+function Style(props) {
+    const { content, children } = props;
+    const contentStr = children || content;
+    const styleContent = encodeURIComponent(`${contentStr}`);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+        children: [
+            `${external_constants_js_namespaceObject.DOCUMENT_STYLE_PLACEHOLDER_START}`,
+            `${styleContent}`,
+            `${external_constants_js_namespaceObject.DOCUMENT_STYLE_PLACEHOLDER_END}`
+        ]
+    });
+}
+exports.Style = __webpack_exports__.Style;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Style"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/document/Title.js

@@ -0,0 +1,42 @@
+"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__, {
+    Title: ()=>Title
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_constants_js_namespaceObject = require("./constants.js");
+function Title() {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("title", {
+        children: external_constants_js_namespaceObject.DOCUMENT_TITLE_PLACEHOLDER
+    });
+}
+exports.Title = __webpack_exports__.Title;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Title"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/document/cli/index.js

@@ -0,0 +1,401 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module1)=>{
+        var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
+        __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__, {
+    default: ()=>cli,
+    documentPlugin: ()=>documentPlugin,
+    getDocumentByEntryName: ()=>getDocumentByEntryName
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_entities_namespaceObject = require("entities");
+const external_module_namespaceObject = require("module");
+var external_module_default = /*#__PURE__*/ __webpack_require__.n(external_module_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("../constants.js");
+const debug = (0, utils_namespaceObject.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)=>(0, external_entities_namespaceObject.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(external_constants_js_namespaceObject.DOCUMENT_SCRIPT_PLACEHOLDER_START) || !html.includes(external_constants_js_namespaceObject.DOCUMENT_SCRIPT_PLACEHOLDER_END)) return html;
+    const nonceAttr = nonce ? `nonce="${nonce}"` : '';
+    return html.replace(new RegExp(`${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_PLACEHOLDER_START}${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_ATTRIBUTES_START}([\\s\\S]*?)${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_ATTRIBUTES_END}([\\s\\S]*?)${external_constants_js_namespaceObject.DOCUMENT_SCRIPT_PLACEHOLDER_END}`, 'g'), (_scriptStr, $1, $2)=>`<script ${decodeURIComponent($1)} ${nonceAttr}>${decodeHtmlEntities(decodeURIComponent($2))}</script>`);
+};
+const processStylePlaceholders = (html)=>{
+    if (!html.includes(external_constants_js_namespaceObject.DOCUMENT_STYLE_PLACEHOLDER_START) || !html.includes(external_constants_js_namespaceObject.DOCUMENT_STYLE_PLACEHOLDER_END)) return html;
+    return html.replace(new RegExp(`${external_constants_js_namespaceObject.DOCUMENT_STYLE_PLACEHOLDER_START}([\\s\\S]*?)${external_constants_js_namespaceObject.DOCUMENT_STYLE_PLACEHOLDER_END}`, 'g'), (_styleStr, $1)=>`<style>${decodeHtmlEntities(decodeURIComponent($1))}</style>`);
+};
+const processCommentPlaceholders = (html)=>{
+    if (!html.includes(external_constants_js_namespaceObject.DOCUMENT_COMMENT_PLACEHOLDER_START) || !html.includes(external_constants_js_namespaceObject.DOCUMENT_COMMENT_PLACEHOLDER_END)) return html;
+    return html.replace(new RegExp(`${external_constants_js_namespaceObject.DOCUMENT_COMMENT_PLACEHOLDER_START}([\\s\\S]*?)${external_constants_js_namespaceObject.DOCUMENT_COMMENT_PLACEHOLDER_END}`, 'g'), (_scriptStr, $1)=>`${decodeHtmlEntities(decodeURIComponent($1))}`);
+};
+const requireFromString = (code, filename)=>{
+    const m = new (external_module_default()).Module(filename, module.parent);
+    m.filename = filename;
+    m.paths = external_module_default().Module._nodeModulePaths(external_path_default().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 = external_constants_js_namespaceObject.DOC_EXT.map((item)=>`${entryDir}${external_path_default().sep}${external_constants_js_namespaceObject.DOCUMENT_FILE_NAME}.${item}`);
+    const fallbackDirs = fallbackDir ? external_constants_js_namespaceObject.DOC_EXT.map((item)=>[
+            fallbackDir,
+            'src',
+            `${external_constants_js_namespaceObject.DOCUMENT_FILE_NAME}.${item}`
+        ].join(external_path_default().sep)) : [];
+    const docFile = (0, utils_namespaceObject.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 (external_module_namespaceObject.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 = external_path_default().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 = external_path_default().join(internalDirectory, CONSTANTS.DOCUMENT_OUTPUT_DIR);
+        const tempEntry = external_path_default().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) {
+                        utils_namespaceObject.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.`;
+                            utils_namespaceObject.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;
+                        utils_namespaceObject.logger.error(`Document child compiler failed to process output for entry "${entryName}": ${err.message}`);
+                        reject(err);
+                    }
+                });
+            } catch (e) {
+                const err = e;
+                utils_namespaceObject.logger.error(`Document child compiler failed to initialize for entry "${entryName}": ${err.message}`);
+                reject(err);
+            }
+        };
+        try {
+            utils_namespaceObject.fs.ensureFile(tempEntry).then(()=>{
+                const entryCode = generateEntryCode(docPath, entryName);
+                return utils_namespaceObject.fs.writeFile(tempEntry, entryCode);
+            }).then(finalize).catch((e)=>{
+                const err = e;
+                utils_namespaceObject.logger.error(`Document child compiler failed to prepare entry file for "${entryName}": ${err.message}`);
+                reject(err);
+            });
+        } catch (e) {
+            const err = e;
+            utils_namespaceObject.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;
+                            utils_namespaceObject.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 = external_path_default().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(external_constants_js_namespaceObject.TOP_PARTICALS_SEPARATOR, ()=>partialsContent.partialsTop).replace(external_constants_js_namespaceObject.HEAD_PARTICALS_SEPARATOR, ()=>partialsContent.partialsHead).replace(external_constants_js_namespaceObject.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(external_constants_js_namespaceObject.DOCUMENT_META_PLACEHOLDER, ()=>metas).replace(external_constants_js_namespaceObject.DOCUMENT_SSR_PLACEHOLDER, ()=>external_constants_js_namespaceObject.HTML_SEPARATOR).replace(external_constants_js_namespaceObject.DOCUMENT_SCRIPTS_PLACEHOLDER, ()=>scripts).replace(external_constants_js_namespaceObject.DOCUMENT_LINKS_PLACEHOLDER, ()=>links).replace(external_constants_js_namespaceObject.DOCUMENT_CHUNKSMAP_PLACEHOLDER, ()=>external_constants_js_namespaceObject.PLACEHOLDER_REPLACER_MAP[external_constants_js_namespaceObject.DOCUMENT_CHUNKSMAP_PLACEHOLDER]).replace(external_constants_js_namespaceObject.DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, ()=>external_constants_js_namespaceObject.PLACEHOLDER_REPLACER_MAP[external_constants_js_namespaceObject.DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]).replace(external_constants_js_namespaceObject.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;
+                        utils_namespaceObject.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;
+exports["default"] = __webpack_exports__["default"];
+exports.documentPlugin = __webpack_exports__.documentPlugin;
+exports.getDocumentByEntryName = __webpack_exports__.getDocumentByEntryName;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "documentPlugin",
+    "getDocumentByEntryName"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});