@modern-js/builder 3.0.0-alpha.1 → 3.0.0

package/dist/cjs/createBuilder.js

@@ -0,0 +1,96 @@
+"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__, {
+    parseConfig: ()=>parseConfig,
+    createRspackBuilder: ()=>createRspackBuilder
+});
+const core_namespaceObject = require("@rsbuild/core");
+const rsbuild_rsc_plugin_js_namespaceObject = require("./rsc/plugins/rsbuild-rsc-plugin.js");
+const parseCommonConfig_js_namespaceObject = require("./shared/parseCommonConfig.js");
+const rscClientBrowserFallback_js_namespaceObject = require("./shared/rsc/rscClientBrowserFallback.js");
+async function parseConfig(builderConfig, options) {
+    builderConfig.performance ??= {};
+    builderConfig.performance.buildCache ??= true;
+    const { rsbuildConfig, rsbuildPlugins } = await (0, parseCommonConfig_js_namespaceObject.parseCommonConfig)(builderConfig, options);
+    const { sri } = builderConfig.security || {};
+    if (sri) if (true === sri) rsbuildConfig.security.sri = {
+        enable: 'auto'
+    };
+    else {
+        const algorithm = Array.isArray(sri.hashFuncNames) ? sri.hashFuncNames[0] : void 0;
+        rsbuildConfig.security.sri = {
+            enable: sri.enabled,
+            algorithm
+        };
+    }
+    if (false === Boolean(rsbuildConfig.tools.lightningcssLoader)) {
+        const { pluginPostcss } = await import("./plugins/postcss.js");
+        rsbuildPlugins.push(pluginPostcss({
+            autoprefixer: builderConfig.tools?.autoprefixer
+        }));
+    }
+    const enableRsc = builderConfig.server?.rsc ?? false;
+    if (enableRsc) {
+        const { rscClientRuntimePath, rscServerRuntimePath, internalDirectory } = options;
+        rsbuildPlugins.push((0, rsbuild_rsc_plugin_js_namespaceObject.rsbuildRscPlugin)({
+            appDir: options.cwd,
+            rscClientRuntimePath,
+            rscServerRuntimePath,
+            internalDirectory
+        }));
+    } else rsbuildPlugins.push((0, rscClientBrowserFallback_js_namespaceObject.rscClientBrowserFallbackPlugin)());
+    return {
+        rsbuildConfig,
+        rsbuildPlugins
+    };
+}
+async function createRspackBuilder(options) {
+    const { cwd = process.cwd(), config, ...rest } = options;
+    const { rsbuildConfig, rsbuildPlugins } = await parseConfig(config, {
+        ...rest,
+        cwd
+    });
+    rsbuildConfig.plugins = [
+        ...rsbuildPlugins,
+        ...rsbuildConfig.plugins || []
+    ];
+    const rsbuild = await (0, core_namespaceObject.createRsbuild)({
+        cwd,
+        rsbuildConfig
+    });
+    return {
+        ...rsbuild
+    };
+}
+exports.createRspackBuilder = __webpack_exports__.createRspackBuilder;
+exports.parseConfig = __webpack_exports__.parseConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRspackBuilder",
+    "parseConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,59 @@
+"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__, {
+    RUNTIME_CHUNK_REGEX: ()=>utils_js_namespaceObject.RUNTIME_CHUNK_REGEX,
+    logger: ()=>core_namespaceObject.logger,
+    RUNTIME_CHUNK_NAME: ()=>utils_js_namespaceObject.RUNTIME_CHUNK_NAME,
+    castArray: ()=>utils_js_namespaceObject.castArray,
+    SERVICE_WORKER_ENVIRONMENT_NAME: ()=>utils_js_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME,
+    isHtmlDisabled: ()=>utils_js_namespaceObject.isHtmlDisabled,
+    createBuilder: ()=>external_createBuilder_js_namespaceObject.createRspackBuilder,
+    parseRspackConfig: ()=>external_createBuilder_js_namespaceObject.parseConfig
+});
+const external_createBuilder_js_namespaceObject = require("./createBuilder.js");
+const core_namespaceObject = require("@rsbuild/core");
+const utils_js_namespaceObject = require("./shared/utils.js");
+exports.RUNTIME_CHUNK_NAME = __webpack_exports__.RUNTIME_CHUNK_NAME;
+exports.RUNTIME_CHUNK_REGEX = __webpack_exports__.RUNTIME_CHUNK_REGEX;
+exports.SERVICE_WORKER_ENVIRONMENT_NAME = __webpack_exports__.SERVICE_WORKER_ENVIRONMENT_NAME;
+exports.castArray = __webpack_exports__.castArray;
+exports.createBuilder = __webpack_exports__.createBuilder;
+exports.isHtmlDisabled = __webpack_exports__.isHtmlDisabled;
+exports.logger = __webpack_exports__.logger;
+exports.parseRspackConfig = __webpack_exports__.parseRspackConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RUNTIME_CHUNK_NAME",
+    "RUNTIME_CHUNK_REGEX",
+    "SERVICE_WORKER_ENVIRONMENT_NAME",
+    "castArray",
+    "createBuilder",
+    "isHtmlDisabled",
+    "logger",
+    "parseRspackConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/devtools.js

@@ -0,0 +1,47 @@
+"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__, {
+    pluginDevtool: ()=>pluginDevtool
+});
+const pluginDevtool = (options)=>({
+        name: 'builder:devtool',
+        setup (api) {
+            const devtoolJs = 'boolean' == typeof options.sourceMap || options.sourceMap?.js !== void 0;
+            if (devtoolJs) return;
+            api.modifyBundlerChain((chain, { isProd, isServer })=>{
+                const prodDevTool = isServer ? 'source-map' : 'hidden-source-map';
+                const devtool = isProd ? prodDevTool : 'cheap-module-source-map';
+                chain.devtool(devtool);
+            });
+        }
+    });
+exports.pluginDevtool = __webpack_exports__.pluginDevtool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginDevtool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/emitRouteFile.js

@@ -0,0 +1,75 @@
+"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__, {
+    pluginEmitRouteFile: ()=>pluginEmitRouteFile,
+    isFileExists: ()=>isFileExists
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+async function isFileExists(file) {
+    return external_node_fs_default().promises.access(file, external_node_fs_default().constants.F_OK).then(()=>true).catch(()=>false);
+}
+const pluginEmitRouteFile = ()=>({
+        name: 'builder:emit-route-file',
+        setup (api) {
+            api.onBeforeStartDevServer(async ({ environments })=>{
+                const { fs, ROUTE_SPEC_FILE } = await import("@modern-js/utils");
+                const routeFilePath = (0, external_node_path_namespaceObject.join)(api.context.distPath, ROUTE_SPEC_FILE);
+                const htmlPaths = Object.values(environments).reduce((prev, curr)=>({
+                        ...prev,
+                        ...curr.htmlPaths
+                    }), {});
+                const routesInfo = Object.entries(htmlPaths).map(([entryName, filename], index)=>({
+                        urlPath: 0 === index ? '/' : `/${entryName}`,
+                        entryName,
+                        entryPath: filename,
+                        isSPA: true
+                    }));
+                if (!await isFileExists(routeFilePath) && routesInfo.length) await fs.outputFile(routeFilePath, JSON.stringify({
+                    routes: routesInfo
+                }, null, 2));
+            });
+        }
+    });
+exports.isFileExists = __webpack_exports__.isFileExists;
+exports.pluginEmitRouteFile = __webpack_exports__.pluginEmitRouteFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isFileExists",
+    "pluginEmitRouteFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/environmentDefaults.js

@@ -0,0 +1,100 @@
+"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__, {
+    pluginEnvironmentDefaults: ()=>pluginEnvironmentDefaults
+});
+const external_node_path_namespaceObject = require("node:path");
+const utils_js_namespaceObject = require("../shared/utils.js");
+const pluginEnvironmentDefaults = (distPath = {})=>({
+        name: 'builder:environment-defaults-plugin',
+        setup (api) {
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                const compatConfig = {};
+                if (config.environments?.[utils_js_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME]) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments[utils_js_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME] = {
+                        output: {
+                            polyfill: 'off',
+                            distPath: {
+                                root: (0, external_node_path_namespaceObject.join)(distPath.root || 'dist', distPath.worker || 'worker'),
+                                js: '',
+                                css: '',
+                                jsAsync: '',
+                                cssAsync: ''
+                            },
+                            filename: {
+                                js: '[name].js'
+                            }
+                        }
+                    };
+                }
+                if (config.environments?.node) {
+                    compatConfig.environments ??= {};
+                    compatConfig.environments.node = {
+                        output: {
+                            emitAssets: false,
+                            distPath: {
+                                root: (0, external_node_path_namespaceObject.join)(distPath.root || 'dist', distPath.server || 'bundles'),
+                                js: '',
+                                css: '',
+                                jsAsync: '',
+                                cssAsync: ''
+                            }
+                        }
+                    };
+                }
+                return compatConfig.environments ? mergeRsbuildConfig(compatConfig, config) : config;
+            });
+            api.modifyRsbuildConfig({
+                handler: (config)=>{
+                    const environmentNameOrder = [
+                        'web',
+                        'node',
+                        'workerSSR'
+                    ];
+                    config.environments = Object.fromEntries(Object.entries(config.environments).sort((a1, a2)=>environmentNameOrder.includes(a1[0]) ? environmentNameOrder.indexOf(a1[0]) - environmentNameOrder.indexOf(a2[0]) : 1));
+                },
+                order: 'post'
+            });
+            api.modifyEnvironmentConfig(async (config, { name })=>{
+                config.output.overrideBrowserslist ??= await (0, utils_js_namespaceObject.getBrowserslistWithDefault)(api.context.rootPath, config, name === utils_js_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME ? 'node' : config.output.target);
+            });
+            api.modifyBundlerChain(async (chain, { environment })=>{
+                const isServiceWorker = environment.name === utils_js_namespaceObject.SERVICE_WORKER_ENVIRONMENT_NAME;
+                if (isServiceWorker) chain.output.library({
+                    ...chain.output.get('library') || {},
+                    type: 'commonjs2'
+                });
+            });
+        }
+    });
+exports.pluginEnvironmentDefaults = __webpack_exports__.pluginEnvironmentDefaults;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginEnvironmentDefaults"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/globalVars.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__, {
+    pluginGlobalVars: ()=>pluginGlobalVars
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const pluginGlobalVars = (options)=>({
+        name: 'builder:global-vars',
+        setup (api) {
+            api.modifyBundlerChain((chain, { env, target, bundler })=>{
+                if (!options) return;
+                const globalVars = (0, utils_namespaceObject.applyOptionsChain)({}, options, {
+                    env,
+                    target
+                });
+                const serializedVars = {};
+                Object.entries(globalVars).forEach(([key, value])=>{
+                    serializedVars[key] = JSON.stringify(value) ?? 'undefined';
+                });
+                chain.plugin('globalVars').use(bundler.DefinePlugin, [
+                    serializedVars
+                ]);
+            });
+        }
+    });
+exports.pluginGlobalVars = __webpack_exports__.pluginGlobalVars;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginGlobalVars"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/htmlMinify.js

@@ -0,0 +1,115 @@
+"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__, {
+    pluginHtmlMinifierTerser: ()=>pluginHtmlMinifierTerser
+});
+const external_ts_deepmerge_namespaceObject = require("ts-deepmerge");
+function applyRemoveConsole(options, config) {
+    const { removeConsole } = config.performance;
+    const compressOptions = 'boolean' == typeof options.compress ? {} : options.compress || {};
+    if (true === removeConsole) options.compress = {
+        ...compressOptions,
+        drop_console: true
+    };
+    else if (Array.isArray(removeConsole)) {
+        const pureFuncs = removeConsole.map((method)=>`console.${method}`);
+        options.compress = {
+            ...compressOptions,
+            pure_funcs: pureFuncs
+        };
+    }
+    return options;
+}
+function getTerserMinifyOptions(config) {
+    const options = {
+        mangle: {
+            safari10: true
+        },
+        format: {
+            ascii_only: 'ascii' === config.output.charset
+        }
+    };
+    if ('none' === config.output.legalComments) {
+        options.format ||= {};
+        options.format.comments = false;
+    }
+    const finalOptions = applyRemoveConsole(options, config);
+    return finalOptions;
+}
+function getMinifyOptions(config) {
+    const minifyJS = getTerserMinifyOptions(config);
+    return {
+        removeComments: false,
+        useShortDoctype: true,
+        keepClosingSlash: true,
+        collapseWhitespace: true,
+        removeRedundantAttributes: true,
+        removeScriptTypeAttributes: true,
+        removeStyleLinkTypeAttributes: true,
+        removeEmptyAttributes: true,
+        minifyJS,
+        minifyCSS: true,
+        minifyURLs: true
+    };
+}
+const pluginHtmlMinifierTerser = ()=>({
+        name: 'builder:plugin-html-minifier-terser',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { isProd, environment })=>{
+                const { output, tools: { htmlPlugin } } = environment.config;
+                const disableHtmlMinify = !isProd || false === output.minify || false === htmlPlugin;
+                const { minify } = await import("html-minifier-terser");
+                const pluginRecord = chain.plugins.entries();
+                const minifyOptions = getMinifyOptions(environment.config);
+                for (const id of Object.keys(pluginRecord)){
+                    if (!id.startsWith('html-')) continue;
+                    const values = pluginRecord[id].values();
+                    const isHtmlRspackPlugin = values.some((item)=>{
+                        const name = item?.name || item.constructor?.name;
+                        return 'HtmlRspackPlugin' === name;
+                    });
+                    if (isHtmlRspackPlugin && !disableHtmlMinify) {
+                        chain.plugin(id).tap((options)=>{
+                            if (!options.length) return options;
+                            const userMinifyOption = options[0].minify;
+                            if (false === userMinifyOption) return options;
+                            const minifyFn = (html)=>minify(html, userMinifyOption ? (0, external_ts_deepmerge_namespaceObject.merge)(minifyOptions, userMinifyOption) : minifyOptions);
+                            options[0].minify = minifyFn;
+                            return options;
+                        });
+                        continue;
+                    }
+                }
+            });
+        }
+    });
+exports.pluginHtmlMinifierTerser = __webpack_exports__.pluginHtmlMinifierTerser;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginHtmlMinifierTerser"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/manifest.js

@@ -0,0 +1,52 @@
+"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__, {
+    pluginManifest: ()=>pluginManifest
+});
+const manifest_js_namespaceObject = require("../shared/manifest.js");
+const pluginManifest = ()=>({
+        name: 'builder:manifest',
+        setup (api) {
+            api.modifyBundlerChain(async (chain, { target, CHAIN_ID })=>{
+                const { RspackManifestPlugin } = await import("rspack-manifest-plugin");
+                const publicPath = chain.output.get('publicPath');
+                chain.plugin(CHAIN_ID.PLUGIN.MANIFEST).use(RspackManifestPlugin, [
+                    {
+                        fileName: 'web' === target ? 'asset-manifest.json' : `asset-manifest-${target}.json`,
+                        publicPath,
+                        generate: manifest_js_namespaceObject.generateManifest
+                    }
+                ]);
+            });
+        }
+    });
+exports.pluginManifest = __webpack_exports__.pluginManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "pluginManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});