@modern-js/runtime 2.69.5 → 3.0.0-alpha.0

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

@@ -1,223 +1,374 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+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__, {
+    documentPlugin: ()=>documentPlugin,
+    default: ()=>cli,
+    getDocumentByEntryName: ()=>getDocumentByEntryName
+});
+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 utils_namespaceObject = require("@modern-js/utils");
+const external_entities_namespaceObject = require("entities");
+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:'
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+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'
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cli_exports = {};
-__export(cli_exports, {
-  default: () => cli_default,
-  documentPlugin: () => documentPlugin,
-  getDocumenByEntryName: () => getDocumenByEntryName
-});
-module.exports = __toCommonJS(cli_exports);
-var import_path = __toESM(require("path"));
-var import_utils = require("@modern-js/utils");
-var import_esbuild = require("esbuild");
-var import_react = __toESM(require("react"));
-var import_server = __toESM(require("react-dom/server"));
-var import_DocumentContext = require("../DocumentContext");
-var import_constants = require("../constants");
-const debug = (0, import_utils.createDebugger)("html_generate");
-const getDocumenByEntryName = function(entrypoints, entryName, fallbackDir) {
-  var _entrypoints_find;
-  const entryDir = (_entrypoints_find = entrypoints.find((item) => item.entryName === entryName)) === null || _entrypoints_find === void 0 ? void 0 : _entrypoints_find.absoluteEntryDir;
-  const entryDirs = import_constants.DOC_EXT.map((item) => `${entryDir}${import_path.default.sep}${import_constants.DOCUMENT_FILE_NAME}.${item}`);
-  const fallbackDirs = fallbackDir ? import_constants.DOC_EXT.map((item) => [
-    fallbackDir,
-    "src",
-    `${import_constants.DOCUMENT_FILE_NAME}.${item}`
-  ].join(import_path.default.sep)) : [];
-  const docFile = (0, import_utils.findExists)([
-    ...entryDirs,
-    ...fallbackDirs
-  ]);
-  return docFile || void 0;
+const getGlobalDocRenderers = ()=>{
+    const g = globalThis;
+    g[CONSTANTS.GLOBAL_DOC_RENDERERS] = g[CONSTANTS.GLOBAL_DOC_RENDERERS] || {};
+    return g[CONSTANTS.GLOBAL_DOC_RENDERERS];
 };
-const documentPlugin = () => ({
-  name: "@modern-js/plugin-document",
-  pre: [
-    "@modern-js/plugin-analyze"
-  ],
-  setup: async (api) => {
-    function getDocParams(params) {
-      const { config, templateParameters, entryName } = params;
-      return {
-        processEnv: process.env,
-        config: {
-          output: config.output
-        },
-        entryName,
-        templateParams: templateParameters
-      };
-    }
-    const documentEntry = (entryName, templateParameters) => {
-      const { entrypoints, internalDirectory, appDirectory } = api.getAppContext();
-      const documentFilePath = getDocumenByEntryName(entrypoints, entryName, appDirectory);
-      if (!documentFilePath) {
-        return null;
-      }
-      return async ({ htmlWebpackPlugin }) => {
-        const config = api.getNormalizedConfig();
-        const documentParams = getDocParams({
-          config,
-          entryName,
-          templateParameters
-        });
-        const tempTsConfigFile = import_path.default.join(internalDirectory, `./document/_tempTsconfig.json`);
-        const userTsConfigFilePath = import_path.default.join(appDirectory, "tsconfig.json");
-        let tsConfig;
-        try {
-          tsConfig = await require(userTsConfigFilePath);
-        } catch (err) {
-          tsConfig = {};
-        }
-        if (tsConfig === null || tsConfig === void 0 ? void 0 : tsConfig.compilerOptions) {
-          tsConfig.compilerOptions.jsx = "react-jsx";
-        } else {
-          tsConfig.compilerOptions = {
-            jsx: "react-jsx"
-          };
-        }
-        import_utils.fs.outputFileSync(tempTsConfigFile, JSON.stringify(tsConfig));
-        const htmlOutputFile = import_path.default.join(internalDirectory, `./document/_${entryName}.html.js`);
-        await (0, import_esbuild.build)({
-          entryPoints: [
-            documentFilePath
-          ],
-          outfile: htmlOutputFile,
-          platform: "node",
-          // change esbuild use the rootDir tsconfig.json as default to tempTsConfigFile
-          tsconfig: tempTsConfigFile,
-          target: "es6",
-          loader: {
-            ".ts": "ts",
-            ".tsx": "tsx"
-          },
-          bundle: true,
-          plugins: [
-            {
-              name: "make-all-packages-external",
-              setup(build2) {
-                build2.onResolve({
-                  filter: /^[^./]|^\.[^./]|^\.\.[^/]/
-                }, (args) => {
-                  let external = true;
-                  if (args.kind === "entry-point") {
-                    external = false;
-                  }
-                  return {
-                    path: args.path,
-                    external
-                  };
+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;
+};
+const applyExternalsPlugin = (child, compiler)=>{
+    const ExternalsPlugin = compiler.rspack?.ExternalsPlugin;
+    if (ExternalsPlugin) new ExternalsPlugin('commonjs', [
+        createExternalHandler(),
+        EXTERNAL_MAPPINGS
+    ]).apply(child);
+};
+const generateEntryCode = (docPath, _entryName)=>`var React = require('react');
+var ReactDomServer = require('react-dom/server');
+var exp = require(${JSON.stringify(docPath)});
+var DocumentContext = require('@meta/runtime/document').DocumentContext;
+
+var Document = exp && exp.default;
+
+// 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;
+
+module.exports = { 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) 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) {
+                            entryName2DocCode.set(entryName, code);
+                            debug('Document child compiler: cached injected bundle for %s', entryName);
+                        } else debug('Document child compiler: empty asset for %s', entryName);
+                        resolve();
+                    } catch (e) {
+                        reject(e);
+                    }
                 });
-              }
+            } catch (e) {
+                reject(e);
             }
-          ]
-        });
-        delete require.cache[require.resolve(htmlOutputFile)];
-        const Document = (await require(htmlOutputFile)).default;
-        const HTMLElement = import_react.default.createElement(import_DocumentContext.DocumentContext.Provider, {
-          value: documentParams
-        }, import_react.default.createElement(Document, null));
-        let html = import_server.default.renderToStaticMarkup(HTMLElement);
-        debug("entry %s's document jsx rendered html: %o", entryName, html);
-        const { partialsByEntrypoint } = api.getAppContext();
-        const scripts = [
-          htmlWebpackPlugin.tags.headTags.filter((item) => item.tagName === "script").join(""),
-          htmlWebpackPlugin.tags.bodyTags.toString()
-        ].join("");
-        const partialsContent = {
-          partialsTop: "",
-          partialsHead: "",
-          partialsBody: ""
         };
-        if (partialsByEntrypoint === null || partialsByEntrypoint === void 0 ? void 0 : partialsByEntrypoint[entryName]) {
-          partialsContent.partialsTop = partialsByEntrypoint[entryName].top.join("\n");
-          partialsContent.partialsHead = partialsByEntrypoint[entryName].head.join("\n");
-          partialsContent.partialsBody = partialsByEntrypoint[entryName].body.join("\n");
-        }
-        html = html.replace(import_constants.TOP_PARTICALS_SEPARATOR, () => partialsContent.partialsTop).replace(import_constants.HEAD_PARTICALS_SEPARATOR, () => partialsContent.partialsHead).replace(import_constants.BODY_PARTICALS_SEPARATOR, () => partialsContent.partialsBody);
-        const links = [
-          htmlWebpackPlugin.tags.headTags.filter((item) => item.tagName === "link").join("")
-        ].join("");
-        const metas = [
-          templateParameters.meta,
-          htmlWebpackPlugin.tags.headTags.filter((item) => item.tagName !== "script" && item.tagName !== "link" && item.tagName !== "title").join("")
-        ].join("");
-        const titles = htmlWebpackPlugin.tags.headTags.filter((item) => item.tagName === "title").join("").replace("<title>", "").replace("</title>", "") || templateParameters.title;
-        if (html.includes(import_constants.DOCUMENT_SCRIPT_PLACEHOLDER_START) && html.includes(import_constants.DOCUMENT_SCRIPT_PLACEHOLDER_END)) {
-          const { nonce } = config.security || {};
-          const nonceAttr = nonce ? `nonce=${nonce}` : "";
-          html = html.replace(new RegExp(`${import_constants.DOCUMENT_SCRIPT_PLACEHOLDER_START}${import_constants.DOCUMENT_SCRIPT_ATTRIBUTES_START}(.*?)${import_constants.DOCUMENT_SCRIPT_ATTRIBUTES_END}(.*?)${import_constants.DOCUMENT_SCRIPT_PLACEHOLDER_END}`, "g"), (_scriptStr, $1, $2) => `<script ${decodeURIComponent($1)} ${nonceAttr}>${decodeURIComponent($2)}</script>`);
-        }
-        if (html.includes(import_constants.DOCUMENT_STYLE_PLACEHOLDER_START) && html.includes(import_constants.DOCUMENT_STYLE_PLACEHOLDER_END)) {
-          html = html.replace(new RegExp(`${import_constants.DOCUMENT_STYLE_PLACEHOLDER_START}(.*?)${import_constants.DOCUMENT_STYLE_PLACEHOLDER_END}`, "g"), (_styleStr, $1) => `<style>${decodeURIComponent($1)}</style>`);
-        }
-        if (html.includes(import_constants.DOCUMENT_COMMENT_PLACEHOLDER_START) && html.includes(import_constants.DOCUMENT_COMMENT_PLACEHOLDER_END)) {
-          html = html.replace(new RegExp(`${import_constants.DOCUMENT_COMMENT_PLACEHOLDER_START}(.*?)${import_constants.DOCUMENT_COMMENT_PLACEHOLDER_END}`, "g"), (_scriptStr, $1) => `${decodeURIComponent($1)}`);
+        try {
+            utils_namespaceObject.fs.ensureFile(tempEntry).then(()=>{
+                const entryCode = generateEntryCode(docPath, entryName);
+                return utils_namespaceObject.fs.writeFile(tempEntry, entryCode);
+            }).then(finalize).catch((e)=>reject(e));
+        } catch (e) {
+            reject(e);
         }
-        const finalHtml = `<!DOCTYPE html>${html}`.replace(import_constants.DOCUMENT_META_PLACEHOLDER, () => metas).replace(import_constants.DOCUMENT_SSR_PLACEHOLDER, () => import_constants.HTML_SEPARATOR).replace(import_constants.DOCUMENT_SCRIPTS_PLACEHOLDER, () => scripts).replace(import_constants.DOCUMENT_LINKS_PLACEHOLDER, () => links).replace(import_constants.DOCUMENT_CHUNKSMAP_PLACEHOLDER, () => import_constants.PLACEHOLDER_REPLACER_MAP[import_constants.DOCUMENT_CHUNKSMAP_PLACEHOLDER]).replace(import_constants.DOCUMENT_SSRDATASCRIPT_PLACEHOLDER, () => import_constants.PLACEHOLDER_REPLACER_MAP[import_constants.DOCUMENT_SSRDATASCRIPT_PLACEHOLDER]).replace(import_constants.DOCUMENT_TITLE_PLACEHOLDER, () => titles);
-        return finalHtml;
-      };
-    };
-    api.config(() => {
-      var _userConfig_tools;
-      const userConfig = api.getConfig();
-      if (((_userConfig_tools = userConfig.tools) === null || _userConfig_tools === void 0 ? void 0 : _userConfig_tools.htmlPlugin) === false) {
-        return {};
-      }
-      return {
-        tools: {
-          htmlPlugin: (options, entry) => {
-            const hackParameters = typeof (options === null || options === void 0 ? void 0 : options.templateParameters) === "function" ? options === null || options === void 0 ? void 0 : options.templateParameters({}, {}, {}, {}) : {
-              ...options === null || options === void 0 ? void 0 : options.templateParameters
+    });
+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) {
+                            debug('Document child compiler make hook failed: %o', e);
+                        }
+                    });
+                }
+                constructor(){
+                    this.name = 'ModernJsDocumentChildCompilerPlugin';
+                }
+            }
+            api.config(()=>{
+                const documentPath = require.resolve('../');
+                return {
+                    resolve: {
+                        alias: {
+                            '@meta/runtime/document$': documentPath.replace(`${external_path_default().sep}cjs${external_path_default().sep}`, `${external_path_default().sep}esm${external_path_default().sep}`).replace(/.js$/, '.mjs')
+                        }
+                    },
+                    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(`Failed to load Document bundle for entry "${entryName}". This is likely because the Document component compilation failed or the bundle was not generated correctly. Please check your Document component implementation.`);
+                const filename = external_path_default().join(internalDirectory, `./${CONSTANTS.DOCUMENT_OUTPUT_DIR}/${CONSTANTS.HTML_OUTPUT_PREFIX}${entryName}${CONSTANTS.HTML_OUTPUT_SUFFIX}`);
+                requireFromString(cached, filename);
+                return {
+                    renderer: renderers[entryName]
+                };
             };
-            const templateContent = documentEntry(
-              entry.entryName,
-              // options,
-              hackParameters
-            );
-            const documentHtmlOptions = templateContent ? {
-              templateContent,
-              // Note: the behavior of inject/modify tags in afterTemplateExecution hook will not take effect
-              inject: false
-            } : {};
-            return {
-              ...options,
-              ...documentHtmlOptions
+            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 = (htmlWebpackPlugin, templateParameters)=>{
+                const scripts = [
+                    htmlWebpackPlugin.tags.headTags.filter((item)=>"script" === item.tagName).join(''),
+                    htmlWebpackPlugin.tags.bodyTags.toString()
+                ].join('');
+                const links = htmlWebpackPlugin.tags.headTags.filter((item)=>'link' === item.tagName).join('');
+                const metas = [
+                    templateParameters.meta,
+                    htmlWebpackPlugin.tags.headTags.filter((item)=>"script" !== item.tagName && 'link' !== item.tagName && 'title' !== item.tagName).join('')
+                ].join('');
+                const titles = htmlWebpackPlugin.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 ({ htmlWebpackPlugin })=>{
+                    const config = api.getNormalizedConfig();
+                    const documentParams = getDocParams({
+                        config: config,
+                        entryName,
+                        templateParameters
+                    });
+                    const { renderer } = await loadRender(entryName, internalDirectory);
+                    let html = renderer?.(documentParams);
+                    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(htmlWebpackPlugin, 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
+                            };
+                        }
+                    }
+                };
+            });
         }
-      };
     });
-  }
-});
-var cli_default = documentPlugin;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  documentPlugin,
-  getDocumenByEntryName
+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
 });