@modern-js/app-tools 3.0.0-beta.0 → 3.0.0

package/dist/cjs/builder/shared/builderPlugins/adapterBasic.js

@@ -0,0 +1,133 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterBasic: ()=>builderPluginAdapterBasic
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const builder_namespaceObject = require("@modern-js/builder");
+const builderPluginAdapterBasic = (options)=>({
+        name: 'builder-plugin-adapter-modern-basic',
+        setup (api) {
+            api.modifyBundlerChain((chain, { target, CHAIN_ID, environment })=>{
+                const isServiceWorker = environment.name === builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyNodeCompat(isServiceWorker, chain);
+                if ('web' === target) {
+                    const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
+                    const depExt = 'js';
+                    chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
+                    chain.module.rule('bare-server-module').test(bareServerModuleReg).use('server-module-loader').loader(external_node_path_default().join(__dirname, `../loaders/serverModuleLoader.${depExt}`));
+                }
+                const { appContext } = options;
+                const { metaName } = appContext;
+                chain.watchOptions({
+                    ignored: [
+                        `[\\\\/](?:node_modules(?![\\\\/]\\.${metaName})|.git)[\\\\/]`
+                    ]
+                });
+            });
+            api.modifyRspackConfig((config, { target, environment })=>{
+                const isServiceWorker = environment.name === builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) {
+                    const extensionAlias = {
+                        '.js': [
+                            '.node.js',
+                            '.server.js',
+                            '.js'
+                        ],
+                        '.jsx': [
+                            '.node.jsx',
+                            '.server.jsx',
+                            '.jsx'
+                        ],
+                        '.ts': [
+                            '.node.ts',
+                            '.server.ts',
+                            '.ts'
+                        ],
+                        '.tsx': [
+                            '.node.tsx',
+                            '.server.tsx',
+                            '.tsx'
+                        ],
+                        '.mjs': [
+                            '.node.mjs',
+                            '.server.mjs',
+                            '.mjs'
+                        ],
+                        '.json': [
+                            '.node.json',
+                            '.server.json',
+                            '.json'
+                        ]
+                    };
+                    config.resolve ??= {};
+                    config.resolve.extensionAlias = {
+                        ...config.resolve.extensionAlias,
+                        ...extensionAlias
+                    };
+                }
+            });
+        }
+    });
+function applyNodeCompat(isServiceWorker, chain) {
+    const nodeExts = [
+        '.node.js',
+        '.node.jsx',
+        '.node.ts',
+        '.node.tsx',
+        '.node.mjs',
+        '.server.js',
+        '.server.jsx',
+        '.server.ts',
+        '.server.tsx',
+        '.server.mjs'
+    ];
+    const webWorkerExts = [
+        '.worker.js',
+        '.worker.jsx',
+        '.worker.ts',
+        '.worker.tsx'
+    ];
+    for (const ext of nodeExts)chain.resolve.extensions.prepend(ext);
+    if (isServiceWorker) for (const ext of webWorkerExts)chain.resolve.extensions.prepend(ext);
+}
+exports.builderPluginAdapterBasic = __webpack_exports__.builderPluginAdapterBasic;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterBasic"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/adapterHtml.js

@@ -0,0 +1,89 @@
+"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__, {
+    builderPluginAdapterHtml: ()=>builderPluginAdapterHtml
+});
+const builder_namespaceObject = require("@modern-js/builder");
+const utils_namespaceObject = require("@modern-js/utils");
+const lodash_namespaceObject = require("@modern-js/utils/lodash");
+const index_js_namespaceObject = require("../bundlerPlugins/index.js");
+const createVirtualModule = (content)=>`data:text/javascript;charset=utf-8,${encodeURIComponent(content)}`;
+const builderPluginAdapterHtml = (options)=>({
+        name: 'builder-plugin-adapter-modern-html',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin, environment })=>{
+                const builderConfig = environment.config;
+                if (!(0, builder_namespaceObject.isHtmlDisabled)(builderConfig, target)) {
+                    applyBottomHtmlPlugin({
+                        options,
+                        chain,
+                        CHAIN_ID,
+                        HtmlBundlerPlugin,
+                        htmlPaths: environment.htmlPaths
+                    });
+                    await injectAssetPrefix({
+                        chain
+                    });
+                }
+            });
+        }
+    });
+async function injectAssetPrefix({ chain }) {
+    const entries = chain.entryPoints.entries() || {};
+    const entryNames = Object.keys(entries);
+    const assetPrefix = (0, utils_namespaceObject.removeTailSlash)(chain.output.get('publicPath') || '');
+    const code = `window.__assetPrefix__ = '${assetPrefix}';`;
+    entryNames.forEach((entryName)=>{
+        entries[entryName].prepend(createVirtualModule(code));
+    });
+}
+function applyBottomHtmlPlugin({ chain, options, CHAIN_ID, HtmlBundlerPlugin, htmlPaths }) {
+    const { normalizedConfig: modernConfig, appContext } = options;
+    for (const entryName of Object.keys(htmlPaths)){
+        const baseTemplateParams = {
+            entryName,
+            title: modernConfig.html.title,
+            mountId: modernConfig.html.templateParameters
+        };
+        chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args)=>[
+                {
+                    ...args[0] || {},
+                    __internal__: true,
+                    bottomTemplate: appContext.htmlTemplates[`__${entryName}-bottom__`] && (0, lodash_namespaceObject.template)(appContext.htmlTemplates[`__${entryName}-bottom__`])(baseTemplateParams)
+                }
+            ]);
+    }
+    chain.plugin('bottom-template').use(index_js_namespaceObject.BottomTemplatePlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+exports.builderPluginAdapterHtml = __webpack_exports__.builderPluginAdapterHtml;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterHtml"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/adapterSSR.js

@@ -0,0 +1,151 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    builderPluginAdapterSSR: ()=>builderPluginAdapterSSR
+});
+const external_path_namespaceObject = require("path");
+const builder_namespaceObject = require("@modern-js/builder");
+const utils_namespaceObject = require("@modern-js/utils");
+const core_namespaceObject = require("@rsbuild/core");
+const utils_js_namespaceObject = require("../../../plugins/analyze/utils.js");
+const index_js_namespaceObject = require("../bundlerPlugins/index.js");
+const builderPluginAdapterSSR = (options)=>({
+        name: 'builder-plugin-adapter-modern-ssr',
+        setup (api) {
+            const { normalizedConfig } = options;
+            api.modifyRsbuildConfig((config)=>(0, core_namespaceObject.mergeRsbuildConfig)(config, {
+                    html: {
+                        inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
+                    },
+                    server: {
+                        compress: isStreamingSSR(normalizedConfig) || (0, utils_namespaceObject.isUseRsc)(normalizedConfig) ? false : void 0
+                    }
+                }));
+            api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
+                const builderConfig = environment.config;
+                const { normalizedConfig } = options;
+                applyRouterPlugin(chain, 'route-plugin', options, HtmlBundlerPlugin);
+                const isServiceWorker = environment.name === builder_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if ('node' === target || isServiceWorker) applyFilterEntriesBySSRConfig({
+                    isProd,
+                    chain,
+                    appNormalizedConfig: normalizedConfig
+                });
+                if ((0, utils_namespaceObject.isUseSSRBundle)(normalizedConfig) || (0, utils_namespaceObject.isUseRsc)(normalizedConfig)) {
+                    await applySSRLoaderEntry(chain, options, isServer);
+                    applySSRDataLoader(chain, options);
+                }
+                if (!(0, builder_namespaceObject.isHtmlDisabled)(builderConfig, target)) applyAsyncChunkHtmlPlugin({
+                    chain,
+                    modernConfig: options.normalizedConfig,
+                    HtmlBundlerPlugin
+                });
+            });
+        }
+    });
+const isStreamingSSR = (userConfig)=>{
+    const isStreaming = (ssr)=>{
+        if (!ssr) return false;
+        if ('boolean' == typeof ssr) return ssr;
+        return 'string' !== ssr.mode;
+    };
+    const { server } = userConfig;
+    if (isStreaming(server.ssr)) return true;
+    if (server?.ssrByEntries && 'object' == typeof server.ssrByEntries) {
+        for (const name of Object.keys(server.ssrByEntries))if (isStreaming(server.ssrByEntries[name])) return true;
+    }
+    return false;
+};
+function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
+    if (isStreamingSSR(modernConfig) || (0, utils_namespaceObject.isUseRsc)(modernConfig)) chain.plugin('html-async-chunk').use(index_js_namespaceObject.HtmlAsyncChunkPlugin, [
+        HtmlBundlerPlugin
+    ]);
+}
+function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
+    const { appContext, normalizedConfig } = options;
+    const { entrypoints } = appContext;
+    const existNestedRoutes = entrypoints.some((entrypoint)=>entrypoint.nestedRoutesEntry);
+    const workerSSR = Boolean(normalizedConfig.deploy.worker?.ssr);
+    const { enableInlineRouteManifests, disableInlineRouteManifests } = normalizedConfig.output;
+    const inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
+    if (existNestedRoutes || workerSSR) chain.plugin(pluginName).use(index_js_namespaceObject.RouterPlugin, [
+        {
+            HtmlBundlerPlugin,
+            enableInlineRouteManifests: inlineRouteManifests,
+            staticJsDir: normalizedConfig.output?.distPath?.js,
+            disableFilenameHash: normalizedConfig.output?.filenameHash === false,
+            scriptLoading: normalizedConfig.html?.scriptLoading,
+            nonce: normalizedConfig.security?.nonce
+        }
+    ]);
+}
+function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
+    const { server: serverConfig, output: outputConfig } = appNormalizedConfig;
+    const entries = chain.entryPoints.entries();
+    if (isProd && (outputConfig?.ssg === true || 'function' == typeof outputConfig?.ssg)) return;
+    if (void 0 === entries) throw new Error('No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required');
+    const entryNames = Object.keys(entries);
+    if (isProd && 1 === entryNames.length && outputConfig?.ssg) return;
+    const ssgEntries = [];
+    if (isProd && outputConfig?.ssgByEntries) {
+        const { ssgByEntries } = outputConfig;
+        entryNames.forEach((name)=>{
+            if (ssgByEntries[name]) ssgEntries.push(name);
+        });
+    }
+    const { ssr, ssrByEntries } = serverConfig || {};
+    entryNames.forEach((name)=>{
+        if (!serverConfig?.rsc && !ssgEntries.includes(name) && !name.includes('server-loaders') && (ssr && ssrByEntries?.[name] === false || !ssr && !ssrByEntries?.[name])) chain.entryPoints.delete(name);
+    });
+}
+async function applySSRLoaderEntry(chain, optinos, isServer) {
+    const { appContext } = optinos;
+    const { internalDirectory } = appContext;
+    const { entrypoints } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName } = entrypoint;
+        const serverLoadersFile = (0, utils_js_namespaceObject.getServerCombinedModueFile)(internalDirectory, entryName);
+        if (isServer) try {
+            await utils_namespaceObject.fs.access(serverLoadersFile, utils_namespaceObject.fs.constants.F_OK);
+            chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
+        } catch (err) {}
+    }));
+}
+function applySSRDataLoader(chain, options) {
+    const { normalizedConfig, appContext } = options;
+    const { appDirectory } = appContext;
+    const { entriesDir = './src' } = normalizedConfig.source;
+    const absolutePath = external_path_namespaceObject.resolve(appDirectory, entriesDir).split(external_path_namespaceObject.sep).join('(\\\\|/)');
+    const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
+    chain.module.rule('ssr-data-loader').test(reg).use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).end();
+}
+exports.builderPluginAdapterSSR = __webpack_exports__.builderPluginAdapterSSR;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterSSR"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/builderHooks.js

@@ -0,0 +1,51 @@
+"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__, {
+    builderPluginAdapterHooks: ()=>builderPluginAdapterHooks
+});
+const builderPluginAdapterHooks = (options)=>({
+        name: 'builder-plugin-support-modern-hooks',
+        setup (api) {
+            const _internalContext = options.appContext._internalContext;
+            const hooks = _internalContext.pluginAPI?.getHooks();
+            api.modifyBundlerChain(async (chain, utils)=>{
+                await hooks?.modifyBundlerChain.call(chain, utils);
+            });
+            api.modifyRsbuildConfig(async (config, utils)=>{
+                await hooks?.modifyRsbuildConfig.call(config, utils);
+            });
+            api.modifyRspackConfig(async (config, utils)=>{
+                await hooks?.modifyRspackConfig.call(config, utils);
+            });
+        }
+    });
+exports.builderPluginAdapterHooks = __webpack_exports__.builderPluginAdapterHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "builderPluginAdapterHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/builderPlugins/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_modules__ = {
+    "./adapterBasic" (module) {
+        module.exports = require("./adapterBasic.js");
+    },
+    "./adapterHtml" (module) {
+        module.exports = require("./adapterHtml.js");
+    },
+    "./adapterSSR" (module) {
+        module.exports = require("./adapterSSR.js");
+    },
+    "./builderHooks" (module) {
+        module.exports = require("./builderHooks.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _adapterBasic__rspack_import_0 = __webpack_require__("./adapterBasic");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterBasic__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterBasic__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _adapterHtml__rspack_import_1 = __webpack_require__("./adapterHtml");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterHtml__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterHtml__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _adapterSSR__rspack_import_2 = __webpack_require__("./adapterSSR");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _adapterSSR__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_adapterSSR__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _builderHooks__rspack_import_3 = __webpack_require__("./builderHooks");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _builderHooks__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_builderHooks__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/bundlerPlugins/HtmlAsyncChunkPlugin.js

@@ -0,0 +1,71 @@
+"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__, {
+    HtmlAsyncChunkPlugin: ()=>HtmlAsyncChunkPlugin
+});
+const builder_namespaceObject = require("@modern-js/builder");
+class HtmlAsyncChunkPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            const hooks = this.htmlPlugin.getCompilationHooks(compilation);
+            hooks.alterAssetTagGroups.tap(this.name, (assets)=>{
+                const headTags = [];
+                const bodyTags = [];
+                const processScriptTag = (tag)=>{
+                    const { attributes } = tag;
+                    if (attributes && true === attributes.defer) {
+                        attributes.async = true;
+                        delete attributes.defer;
+                    }
+                    const src = attributes?.src;
+                    const isRuntimeChunk = src && builder_namespaceObject.RUNTIME_CHUNK_REGEX.test(src);
+                    return isRuntimeChunk ? bodyTags : headTags;
+                };
+                for (const tag of [
+                    ...assets.headTags,
+                    ...assets.bodyTags
+                ])if ("script" === tag.tagName) processScriptTag(tag).push(tag);
+                else (assets.headTags.includes(tag) ? headTags : bodyTags).push(tag);
+                return {
+                    ...assets,
+                    headTags,
+                    bodyTags
+                };
+            });
+        });
+    }
+    constructor(htmlPlugin){
+        this.name = 'HtmlAsyncChunkPlugin';
+        this.htmlPlugin = htmlPlugin;
+    }
+}
+exports.HtmlAsyncChunkPlugin = __webpack_exports__.HtmlAsyncChunkPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HtmlAsyncChunkPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/builder/shared/bundlerPlugins/HtmlBottomTemplate.js

@@ -0,0 +1,56 @@
+"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__, {
+    BottomTemplatePlugin: ()=>BottomTemplatePlugin
+});
+class BottomTemplatePlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(this.name, (compilation)=>{
+            this.htmlPlugin.getCompilationHooks(compilation).beforeEmit.tap(this.name, (data)=>{
+                if (!data.plugin.options?.__internal__) return data;
+                if (this.bottomTemplateReg.test(data.html)) {
+                    data.html = data.html.replace(this.bottomTemplateReg, '');
+                    const { bottomTemplate } = data.plugin.options;
+                    if (bottomTemplate) data.html = data.html.replace(this.bodyRegExp, (match)=>`\n${bottomTemplate}\n${match}`);
+                }
+                return data;
+            });
+        });
+    }
+    constructor(htmlPlugin){
+        this.bottomTemplateReg = /<!--<\?-\s*bottomTemplate\s*\?>-->/;
+        this.bodyRegExp = /(<\/\s*body\s*>)/i;
+        this.htmlPlugin = htmlPlugin;
+        this.name = 'bottom-template';
+    }
+}
+exports.BottomTemplatePlugin = __webpack_exports__.BottomTemplatePlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BottomTemplatePlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});