@unpackjs/core 4.4.0 → 4.6.0

package/dist/index.js

@@ -20,7 +20,6 @@ import { parse } from "stacktrace-parser";
 import node_zlib from "node:zlib";
 import magic_string from "magic-string";
 import { expand } from "dotenv-expand";
-import node_assert from "node:assert";
 import { RspackDevServer } from "@rspack/dev-server";
 import { exec, spawn } from "node:child_process";
 import chokidar from "chokidar";
@@ -122,7 +121,7 @@ let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULE
   </body>
 </html>`, JS_REGEX = /\.[jt]s$/, JSX_REGEX = /\.[jt]sx$/, SCRIPT_REGEX = /\.[jt]sx?$/;
 var utils_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-let { merge: mergeConfig } = __webpack_require__("compiled/webpack-merge"), { default: launchEditor } = __webpack_require__("compiled/launch-editor"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
+let { merge: utils_mergeConfig } = __webpack_require__("compiled/webpack-merge"), { default: launchEditor } = __webpack_require__("compiled/launch-editor"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
     process.env.NODE_ENV = env;
 }, setDevServer = (isDevServer)=>{
     process.env.DEV_SERVER = isDevServer ? 'true' : 'false';
@@ -638,7 +637,7 @@ let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|
         'react-router-dom': 'ReactRouterDOM'
     };
     return externalAlias[pkgName] ? externalAlias[pkgName] : pkgName.replace(/^@/, '').split(/[/\-.]/).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
-}, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, normalizeSvg = (content)=>content.replace(/<\?xml[\s\S]*?\?>/gi, '').replace(/<!DOCTYPE[\s\S]*?>/gi, '').replace(/<!--[\s\S]*?-->/g, '').trim(), extractSvgContent = (content)=>{
+}, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, normalizeSvg = (content)=>content.replace(/<\?xml[\s\S]*?\?>/gi, '').replace(/<!DOCTYPE[\s\S]*?>/gi, '').replace(/<!--[\s\S]*?-->/g, '').trim(), extractSvgContent = (content)=>{
     let match = content.match(/<svg\b([^>]*)>/i), viewBoxMatch = match?.[1]?.match(/viewBox\s*=\s*["']([^"']+)["']/i);
     return {
         inner: content.replace(/^[\s\S]*?<svg\b[^>]*>/i, '').replace(/<\/svg>[\s\S]*$/i, '').trim(),
@@ -783,105 +782,17 @@ async function applyCacheConfig({ config, unpackConfig, envFilePaths }) {
     let cacheConfig = isPlainObject(unpackConfig.performance.cache) ? unpackConfig.performance.cache : {}, buildDependencies = await getBuildDependencies(unpackConfig.root);
     buildDependencies.userBuildDependencies = cacheConfig.buildDependencies || [], buildDependencies.envFilePaths = envFilePaths;
     let cacheDirectory = node_path.resolve(unpackConfig.root, cacheConfig.cacheDirectory || `${unpackConfig._context.cachePath}/cache`, utils_isDevServer() ? 'dev' : 'build');
-    return mergeConfig(config, {
-        cache: !0,
-        experiments: {
-            cache: {
-                type: 'persistent',
-                buildDependencies: Object.values(buildDependencies).flat(),
-                storage: {
-                    type: 'filesystem',
-                    directory: cacheDirectory
-                }
+    return utils_mergeConfig(config, {
+        cache: {
+            type: 'persistent',
+            buildDependencies: Object.values(buildDependencies).flat(),
+            storage: {
+                type: 'filesystem',
+                directory: cacheDirectory
             }
         }
     });
 }
-globalScope[TRANSFORM_TIMING_STORE] = transformTimingMap;
-let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, SPLIT_STRATEGY_DISPATCHER = {
-    'split-by-module': function(ctx) {
-        let { forceSplittingGroups, defaultConfig } = ctx;
-        return {
-            ...defaultConfig,
-            minSize: 0,
-            maxInitialRequests: 1 / 0,
-            cacheGroups: {
-                ...defaultConfig.cacheGroups,
-                ...forceSplittingGroups,
-                vendors: {
-                    priority: -9,
-                    test: NODE_MODULES_REGEX,
-                    name: (module)=>module ? function(modulePath) {
-                            let handleModuleContext = modulePath?.match(MODULE_PATH_REGEX);
-                            if (!handleModuleContext) return;
-                            let [, scope, name] = handleModuleContext;
-                            return [
-                                'npm',
-                                (scope ?? '').replace('@', ''),
-                                name
-                            ].filter(Boolean).join('.');
-                        }(module.context) : void 0
-                }
-            }
-        };
-    },
-    'split-by-size': function(ctx) {
-        let { forceSplittingGroups, defaultConfig, chunkSplit } = ctx;
-        return node_assert('split-by-size' === chunkSplit.strategy), {
-            ...defaultConfig,
-            minSize: chunkSplit.minSize ?? 50000,
-            maxSize: chunkSplit.maxSize ?? 500000,
-            cacheGroups: {
-                ...defaultConfig.cacheGroups,
-                ...forceSplittingGroups
-            }
-        };
-    },
-    custom: function(ctx) {
-        let userSplitChunks, { forceSplittingGroups, defaultConfig, chunkSplit } = ctx;
-        if ('splitChunks' in chunkSplit && (userSplitChunks = chunkSplit.splitChunks), void 0 === userSplitChunks) return {
-            ...defaultConfig,
-            cacheGroups: {
-                ...defaultConfig.cacheGroups,
-                ...forceSplittingGroups
-            }
-        };
-        if (!1 === userSplitChunks) return Object.keys(forceSplittingGroups).length > 0 && {
-            chunks: 'all',
-            cacheGroups: {
-                ...forceSplittingGroups
-            }
-        };
-        let baseConfig = userSplitChunks;
-        return {
-            ...baseConfig,
-            cacheGroups: {
-                ...baseConfig.cacheGroups || {},
-                ...forceSplittingGroups
-            }
-        };
-    },
-    'all-in-one': function(_ctx) {
-        return !1;
-    },
-    'single-vendor': function(ctx) {
-        let { defaultConfig, forceSplittingGroups } = ctx;
-        return {
-            ...defaultConfig,
-            cacheGroups: {
-                ...defaultConfig.cacheGroups,
-                singleVendor: {
-                    test: NODE_MODULES_REGEX,
-                    priority: 0,
-                    chunks: 'all',
-                    name: 'vendor',
-                    enforce: !0
-                },
-                ...forceSplittingGroups
-            }
-        };
-    }
-};
 async function getEntry(root, customEntry) {
     let entry;
     if (entry = customEntry ? node_path.resolve(root, customEntry) : (await external_tinyglobby_glob('(index|main).{js,ts,jsx,tsx}', {
@@ -890,10 +801,43 @@ async function getEntry(root, customEntry) {
     }))[0], !node_fs.existsSync(entry)) throw Error('could not find entry file');
     return entry;
 }
+globalScope[TRANSFORM_TIMING_STORE] = transformTimingMap;
 let getOutputFilename = ({ type, hash, async })=>{
     let FILENAME = utils_isProd() && !1 !== hash ? PROD_DEFAULT_FILENAME : DEV_DEFAULT_FILENAME;
     return async ? 'js' === type ? FILENAME.jsAsync : FILENAME.cssAsync : FILENAME[type];
-};
+}, getCssLoader = (unpackConfig)=>unpackConfig.css?.transformer === 'lightningcss' ? {
+        loader: 'builtin:lightningcss-loader',
+        options: {
+            targets: esVersionToBrowserslist(unpackConfig.build.target),
+            ...unpackConfig.css?.lightningcssLoader
+        }
+    } : {
+        loader: getCompiledPkgPath('postcss-loader'),
+        options: {
+            sourceMap: unpackConfig.css?.sourceMap,
+            ...unpackConfig.css?.postcssLoader
+        }
+    }, getSassLoader = (unpackConfig)=>({
+        loader: getCompiledPkgPath('sass-loader'),
+        options: {
+            api: 'modern-compiler',
+            implementation: getUserDepPath(unpackConfig.root, [
+                'sass-embedded',
+                'sass'
+            ]),
+            sourceMap: unpackConfig.css?.sourceMap,
+            ...unpackConfig.css?.sassLoader
+        }
+    }), getLessLoader = (unpackConfig)=>({
+        loader: getCompiledPkgPath('less-loader'),
+        options: utils_mergeConfig({
+            lessOptions: {
+                javascriptEnabled: !0
+            },
+            implementation: getUserDepPath(unpackConfig.root, 'less'),
+            sourceMap: unpackConfig.css?.sourceMap
+        }, unpackConfig.css?.lessLoader || {})
+    });
 var css_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 async function applyHtmlConfig({ config, unpackConfig }) {
     let htmlConfig = unpackConfig.html || {}, { template, templateContent } = getHtmlTemplateOrContent(htmlConfig.template, unpackConfig.root), templateParameters = {
@@ -926,7 +870,7 @@ class JsMinifyPlugin {
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "4.4.0",
+            version: "4.6.0",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -961,38 +905,11 @@ class JsMinifyPlugin {
         }));
     }
 }
-class Spinner {
-    chars = [
-        '⠋',
-        '⠙',
-        '⠹',
-        '⠸',
-        '⠼',
-        '⠴',
-        '⠦',
-        '⠧',
-        '⠇',
-        '⠏'
-    ];
-    currentIndex = 0;
-    lastUpdateTime = 0;
-    interval = 100;
-    getCurrentChar() {
-        let now = Date.now();
-        return now - this.lastUpdateTime >= this.interval && (this.currentIndex = (this.currentIndex + 1) % this.chars.length, this.lastUpdateTime = now), this.chars[this.currentIndex];
-    }
-    reset() {
-        this.currentIndex = 0, this.lastUpdateTime = 0;
-    }
-}
 class ProgressBar {
     prefix = 'transforming';
-    spinner = new Spinner();
-    update({ current: originalCurrent, message = '' }) {
-        let { columns: terminalWidth } = process.stdout, current = originalCurrent;
-        originalCurrent >= 0.98 && (current = 1);
-        let loadingChar = this.spinner.getCurrentChar(), messageWidth = terminalWidth - this.prefix.length - (1 === current ? 10 : 9);
-        logUpdate(`${loadingChar} ${this.prefix} (${Math.floor(100 * current)}%) ${colors.dim(message.slice(0, messageWidth).padEnd(messageWidth, ' '))}`), 1 === current && clearLine();
+    update({ percentage, message = '' }) {
+        let { columns: terminalWidth } = process.stdout, messageWidth = terminalWidth - this.prefix.length - (1 === percentage ? 10 : 9);
+        logUpdate(`${this.prefix} (${Math.floor(100 * percentage)}%) ${colors.dim(message.slice(0, messageWidth).padEnd(messageWidth, ' '))}`), 1 === percentage && clearLine();
     }
 }
 function isLikelyFile(filePath) {
@@ -1054,10 +971,10 @@ class ProgressLitePlugin {
 class ProgressPlugin extends rspack.ProgressPlugin {
     progressBar = new ProgressBar();
     constructor(){
-        super((percentage, msg, ...args)=>{
+        super((percentage, message)=>{
             utils_isProd() && this.progressBar.update({
-                current: percentage,
-                message: `${msg} ${args.join(' ')}`
+                percentage,
+                message
             });
         });
     }
@@ -1070,7 +987,6 @@ class ProgressPlugin extends rspack.ProgressPlugin {
 let registerHooks_PLUGIN_NAME = 'RegisterHooksPlugin';
 class RegisterHooksPlugin {
     isFirstCompile = !0;
-    lastVirtualModules = new Map();
     lastLoadedModules = new Map();
     resolveIdTimings = new Map();
     loadTimings = new Map();
@@ -1116,15 +1032,9 @@ class RegisterHooksPlugin {
                 let loaded = await load(id);
                 null !== loaded && prev !== loaded && (this.lastLoadedModules.set(id, loaded), virtualModulesPlugin.writeModule(id, loaded));
             }
-        }, updateVirtualModules = ()=>{
-            applyPluginsByHookSync('virtualModules', (impl)=>{
-                Object.entries(impl()).forEach(([path, content])=>{
-                    this.lastVirtualModules.get(path) !== content && (this.lastVirtualModules.set(path, content), virtualModulesPlugin.writeModule(path, content));
-                });
-            });
         };
         compiler.hooks.thisCompilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
-            updateVirtualModules(), applyPluginsByHook('processAssets', (impl, plugin)=>{
+            applyPluginsByHookSync('processAssets', (impl, plugin)=>{
                 let { stage, handler } = impl;
                 compilation.hooks.processAssets.tapPromise({
                     name: registerHooks_PLUGIN_NAME,
@@ -1168,7 +1078,7 @@ class RegisterHooksPlugin {
             }), this.isFirstCompile = !1;
         }), compiler.hooks.afterDone.tap(registerHooks_PLUGIN_NAME, ()=>{
             this.isCompiling = !1, isDev() && (clearTimeout(this.idleTimer), this.idleTimer = setTimeout(()=>{
-                this.isCompiling || (updateVirtualModules(), updateLoadedModules());
+                this.isCompiling || updateLoadedModules();
             }, 50));
         });
     }
@@ -1202,20 +1112,20 @@ async function applyTypeCheckConfig({ config, unpackConfig }) {
         }
     })), config;
 }
-var bundler_config_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-async function getBundlerConfig(originalUnpackConfig) {
+var rspack_config_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+async function getRspackConfig(originalUnpackConfig) {
     setCurrentUnpackConfig(originalUnpackConfig);
-    let { plugins, bundlerConfig, ...rest } = originalUnpackConfig;
+    let { plugins, rspack: rspackConfig, ...rest } = originalUnpackConfig;
     await applyPluginsByHook('config', async (impl)=>{
         rest = await impl(rest, {
             ...originalUnpackConfig._context,
-            mergeConfig: mergeConfig
+            mergeConfig: utils_mergeConfig
         });
     });
     let unpackConfig = {
         ...rest,
         plugins,
-        bundlerConfig
+        rspack: rspackConfig
     };
     setCurrentUnpackConfig(unpackConfig), await applyPluginsByHook('configResolved', async (impl)=>{
         await impl(unpackConfig, originalUnpackConfig._context);
@@ -1313,9 +1223,14 @@ async function getBundlerConfig(originalUnpackConfig) {
                 {
                     test: /\.wasm$/,
                     dependency: 'url',
-                    type: 'asset/resource'
+                    type: 'webassembly/async'
                 }
-            ]
+            ],
+            parser: {
+                javascript: {
+                    exportsPresence: 'warn'
+                }
+            }
         },
         plugins: [
             new rspack.DefinePlugin({
@@ -1365,20 +1280,18 @@ async function getBundlerConfig(originalUnpackConfig) {
             entries: !!unpackConfig.mpa
         },
         experiments: {
-            css: !1,
-            asyncWebAssembly: !0,
             nativeWatcher: !0
         },
         optimization: {
             moduleIds: isDev() ? 'named' : 'deterministic',
             minimize: !!unpackConfig.build?.minify && utils_isProd(),
             minimizer: [
-                new JsMinifyPlugin(mergeConfig({
+                new JsMinifyPlugin(utils_mergeConfig({
                     compress: {
                         target: unpackConfig.build.target
                     }
                 }, minifyOptions.oxc || {})),
-                new rspack.LightningCssMinimizerRspackPlugin(mergeConfig({
+                new rspack.LightningCssMinimizerRspackPlugin(utils_mergeConfig({
                     minimizerOptions: {
                         targets: esVersionToBrowserslist(unpackConfig.build.target)
                     }
@@ -1400,7 +1313,7 @@ async function getBundlerConfig(originalUnpackConfig) {
             enforce: 'pre',
             use: [
                 {
-                    loader: node_path.resolve(bundler_config_dirname, './transformLoader.js'),
+                    loader: node_path.resolve(rspack_config_dirname, './transformLoader.js'),
                     options: {
                         handler,
                         pluginName: plugin.name
@@ -1408,261 +1321,137 @@ async function getBundlerConfig(originalUnpackConfig) {
                 }
             ]
         });
-    }), config = (({ config, unpackConfig })=>{
-        let { chunkSplit } = unpackConfig.performance || {};
-        if (chunkSplit?.strategy) {
-            let forceSplittingGroups = {};
-            chunkSplit?.forceSplitting && (forceSplittingGroups = function(forceSplitting, strategy) {
-                let cacheGroups = {};
-                for (let [key, regexp] of Array.isArray(forceSplitting) ? forceSplitting.map((regexp, index)=>[
-                        `force-split-${index}`,
-                        regexp
-                    ]) : Object.entries(forceSplitting))cacheGroups[key] = {
-                    test: regexp,
-                    name: key,
-                    chunks: 'all',
-                    priority: +('single-vendor' === strategy),
-                    enforce: !0
-                };
-                return cacheGroups;
-            }(chunkSplit.forceSplitting, chunkSplit.strategy)), set(config, [
-                'optimization',
-                'splitChunks'
-            ], SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
-                defaultConfig: {
-                    chunks: 'all'
-                },
-                forceSplittingGroups,
-                chunkSplit
-            }));
-        }
-        return config;
-    })({
-        config: config = unpackConfig.css?.native ? function({ config, unpackConfig }) {
-            config.output.cssFilename = getOutputFilename({
-                type: 'css',
-                hash: unpackConfig.build?.filenameHash
-            }), config.output.cssChunkFilename = getOutputFilename({
-                type: 'css',
-                hash: unpackConfig.build?.filenameHash,
-                async: !0
-            }), set(config, [
-                'experiments',
-                'css'
-            ], !0);
-            let sourceMap = unpackConfig.css?.sourceMap;
-            set(config, [
-                'module',
-                'parser',
-                'css/module'
-            ], {
-                namedExports: !1
-            }), set(config, [
-                'module',
-                'generator',
-                'css/module'
-            ], {
-                localIdentName: CSS_MODULES_LOCAL_IDENT_NAME,
-                exportsConvention: CSS_MODULES_EXPORTS_CONVENTION
-            });
-            let withCssModules = ({ use })=>({
-                    resourceQuery: /[?&]module(?:[=&]|$)/,
-                    use: [
-                        isDev() && {
-                            loader: node_path.resolve(nativeCss_dirname, './typedCssModulesLoader.js')
-                        },
-                        ...use
-                    ].filter(Boolean),
-                    type: 'css/module'
-                }), getLessLoader = ()=>({
-                    loader: getCompiledPkgPath('less-loader'),
-                    options: mergeConfig({
-                        lessOptions: {
-                            javascriptEnabled: !0
-                        },
-                        implementation: getUserDepPath(unpackConfig.root, 'less'),
-                        sourceMap
-                    }, unpackConfig.css?.lessLoader || {})
-                }), getCssLoader = ()=>unpackConfig.css?.transformer === 'lightningcss' ? {
-                    loader: 'builtin:lightningcss-loader',
-                    options: {
-                        targets: esVersionToBrowserslist(unpackConfig.build.target),
-                        ...unpackConfig.css?.lightningcssLoader
-                    }
-                } : {
-                    loader: getCompiledPkgPath('postcss-loader'),
-                    options: {
-                        sourceMap,
-                        ...unpackConfig.css?.postcssLoader
-                    }
-                }, getSassLoader = ()=>({
-                    loader: getCompiledPkgPath('sass-loader'),
-                    options: {
-                        api: 'modern-compiler',
-                        implementation: getUserDepPath(unpackConfig.root, [
-                            'sass-embedded',
-                            'sass'
-                        ]),
-                        sourceMap,
-                        ...unpackConfig.css?.sassLoader
-                    }
-                });
-            return config.module.rules.push({
-                test: /\.css$/i,
-                oneOf: [
-                    withCssModules({
-                        use: [
-                            getCssLoader()
-                        ]
-                    }),
-                    {
-                        use: [
-                            getCssLoader()
-                        ],
-                        type: 'css'
-                    }
-                ].filter(Boolean)
-            }), config.module.rules.push({
-                test: /\.less$/i,
-                oneOf: [
-                    withCssModules({
-                        use: [
-                            getCssLoader(),
-                            getLessLoader()
-                        ]
-                    }),
-                    {
-                        use: [
-                            getCssLoader(),
-                            getLessLoader()
-                        ],
-                        type: 'css'
-                    }
-                ].filter(Boolean)
-            }), config.module.rules.push({
-                test: /\.s[ac]ss$/i,
+    }), config = unpackConfig.css?.native ? function({ config, unpackConfig }) {
+        config.output.cssFilename = getOutputFilename({
+            type: 'css',
+            hash: unpackConfig.build?.filenameHash
+        }), config.output.cssChunkFilename = getOutputFilename({
+            type: 'css',
+            hash: unpackConfig.build?.filenameHash,
+            async: !0
+        }), set(config, [
+            'module',
+            'parser',
+            'css/module'
+        ], {
+            namedExports: !1
+        }), set(config, [
+            'module',
+            'generator',
+            'css/module'
+        ], {
+            localIdentName: CSS_MODULES_LOCAL_IDENT_NAME,
+            exportsConvention: CSS_MODULES_EXPORTS_CONVENTION
+        });
+        let createStyleRule = (test, items)=>{
+            let use = items.filter(Boolean);
+            return {
+                test,
                 oneOf: [
-                    withCssModules({
-                        use: [
-                            getCssLoader(),
-                            getSassLoader()
-                        ]
+                    (({ use })=>({
+                            resourceQuery: /[?&]module(?:[=&]|$)/,
+                            use: [
+                                isDev() && {
+                                    loader: node_path.resolve(nativeCss_dirname, './typedCssModulesLoader.js')
+                                },
+                                ...use
+                            ].filter(Boolean),
+                            type: 'css/module'
+                        }))({
+                        use
                     }),
                     {
-                        use: [
-                            getCssLoader(),
-                            getSassLoader()
-                        ],
+                        use,
                         type: 'css'
                     }
-                ].filter(Boolean)
-            }), config;
-        }({
-            config,
-            unpackConfig
-        }) : function({ config, unpackConfig }) {
-            let sourceMap = unpackConfig.css?.sourceMap, getCommonRules = ({ importLoaders })=>[
-                    utils_isDevServer() ? {
-                        loader: getCompiledPkgPath('style-loader')
-                    } : {
-                        loader: rspack.CssExtractRspackPlugin.loader,
-                        options: {
-                            defaultExport: !0
-                        }
-                    },
-                    isDev() && {
-                        loader: node_path.resolve(css_dirname, './typedCssModulesLoader.js')
-                    },
-                    {
-                        loader: getCompiledPkgPath('css-loader'),
-                        options: {
-                            importLoaders,
-                            modules: {
-                                auto: (_, resourceQuery)=>resourceQuery?.includes('module'),
-                                localIdentName: CSS_MODULES_LOCAL_IDENT_NAME,
-                                exportLocalsConvention: CSS_MODULES_EXPORTS_CONVENTION,
-                                namedExport: !1
-                            },
-                            sourceMap
-                        }
-                    }
-                ].filter(Boolean);
-            utils_isDevServer() || config.plugins.push(new rspack.CssExtractRspackPlugin({
-                filename: getOutputFilename({
-                    type: 'css',
-                    hash: unpackConfig.build?.filenameHash
-                }),
-                chunkFilename: getOutputFilename({
-                    type: 'css',
-                    hash: unpackConfig.build?.filenameHash,
-                    async: !0
-                }),
-                ignoreOrder: !0
-            }));
-            let getCssLoader = ()=>unpackConfig.css?.transformer === 'lightningcss' ? {
-                    loader: 'builtin:lightningcss-loader',
-                    options: {
-                        targets: esVersionToBrowserslist(unpackConfig.build.target),
-                        ...unpackConfig.css?.lightningcssLoader
-                    }
+                ]
+            };
+        };
+        return config.module.rules.push(createStyleRule(/\.css$/i, [
+            getCssLoader(unpackConfig),
+            unpackConfig.css?.tailwindcss && {
+                loader: require.resolve('@tailwindcss/webpack')
+            }
+        ])), config.module.rules.push(createStyleRule(/\.less$/i, [
+            getCssLoader(unpackConfig),
+            getLessLoader(unpackConfig)
+        ])), config.module.rules.push(createStyleRule(/\.s[ac]ss$/i, [
+            getCssLoader(unpackConfig),
+            getSassLoader(unpackConfig)
+        ])), config;
+    }({
+        config,
+        unpackConfig
+    }) : function({ config, unpackConfig }) {
+        let getCommonRules = ({ importLoaders })=>[
+                utils_isDevServer() ? {
+                    loader: getCompiledPkgPath('style-loader')
                 } : {
-                    loader: getCompiledPkgPath('postcss-loader'),
+                    loader: rspack.CssExtractRspackPlugin.loader,
                     options: {
-                        sourceMap,
-                        ...unpackConfig.css?.postcssLoader
-                    }
-                };
-            return config.module.rules.push({
-                test: /\.less$/i,
-                use: [
-                    ...getCommonRules({
-                        importLoaders: 2
-                    }),
-                    getCssLoader(),
-                    {
-                        loader: getCompiledPkgPath('less-loader'),
-                        options: mergeConfig({
-                            lessOptions: {
-                                javascriptEnabled: !0
-                            },
-                            implementation: getUserDepPath(unpackConfig.root, 'less'),
-                            sourceMap
-                        }, unpackConfig.css?.lessLoader || {})
+                        defaultExport: !0
                     }
-                ]
-            }), config.module.rules.push({
-                test: /\.css$/i,
-                use: [
-                    ...getCommonRules({
-                        importLoaders: 1
-                    }),
-                    getCssLoader()
-                ]
-            }), config.module.rules.push({
-                test: /\.s[ac]ss$/i,
-                use: [
-                    ...getCommonRules({
-                        importLoaders: 2
-                    }),
-                    getCssLoader(),
-                    {
-                        loader: getCompiledPkgPath('sass-loader'),
-                        options: {
-                            api: 'modern-compiler',
-                            implementation: getUserDepPath(unpackConfig.root, [
-                                'sass-embedded',
-                                'sass'
-                            ]),
-                            sourceMap,
-                            ...unpackConfig.css?.sassLoader
-                        }
+                },
+                isDev() && {
+                    loader: node_path.resolve(css_dirname, './typedCssModulesLoader.js')
+                },
+                {
+                    loader: getCompiledPkgPath('css-loader'),
+                    options: {
+                        importLoaders,
+                        modules: {
+                            auto: (_, resourceQuery)=>resourceQuery?.includes('module'),
+                            localIdentName: CSS_MODULES_LOCAL_IDENT_NAME,
+                            exportLocalsConvention: CSS_MODULES_EXPORTS_CONVENTION,
+                            namedExport: !1
+                        },
+                        sourceMap: unpackConfig.css?.sourceMap
                     }
-                ]
-            }), config;
-        }({
-            config,
-            unpackConfig
-        }),
+                }
+            ].filter(Boolean);
+        return utils_isDevServer() || config.plugins.push(new rspack.CssExtractRspackPlugin({
+            filename: getOutputFilename({
+                type: 'css',
+                hash: unpackConfig.build?.filenameHash
+            }),
+            chunkFilename: getOutputFilename({
+                type: 'css',
+                hash: unpackConfig.build?.filenameHash,
+                async: !0
+            }),
+            ignoreOrder: !0
+        })), config.module.rules.push({
+            test: /\.less$/i,
+            use: [
+                ...getCommonRules({
+                    importLoaders: 2
+                }),
+                getCssLoader(unpackConfig),
+                getLessLoader(unpackConfig)
+            ]
+        }), config.module.rules.push({
+            test: /\.css$/i,
+            use: [
+                ...getCommonRules({
+                    importLoaders: unpackConfig.css?.tailwindcss ? 2 : 1
+                }),
+                getCssLoader(unpackConfig),
+                unpackConfig.css?.tailwindcss && {
+                    loader: require.resolve('@tailwindcss/webpack')
+                }
+            ].filter(Boolean)
+        }), config.module.rules.push({
+            test: /\.s[ac]ss$/i,
+            use: [
+                ...getCommonRules({
+                    importLoaders: 2
+                }),
+                getCssLoader(unpackConfig),
+                getSassLoader(unpackConfig)
+            ]
+        }), config;
+    }({
+        config,
         unpackConfig
     }), unpackConfig.mpa || (config = await applyHtmlConfig({
         config,
@@ -1710,18 +1499,18 @@ async function getBundlerConfig(originalUnpackConfig) {
     }({
         config,
         unpackConfig
-    })), await applyPluginsByHook('bundlerConfig', async (impl)=>{
+    })), await applyPluginsByHook('rspackConfig', async (impl)=>{
         config = await impl(config, {
             ...originalUnpackConfig._context,
             unpackConfig,
-            mergeConfig: mergeConfig
+            mergeConfig: utils_mergeConfig
         });
-    }), unpackConfig.bundlerConfig && (config = isFunction(unpackConfig.bundlerConfig) ? await unpackConfig.bundlerConfig(config, {
-        mergeConfig: mergeConfig
-    }) : mergeConfig(config, unpackConfig.bundlerConfig)), config;
+    }), unpackConfig.rspack && (config = isFunction(unpackConfig.rspack) ? await unpackConfig.rspack(config, {
+        mergeConfig: utils_mergeConfig
+    }) : utils_mergeConfig(config, unpackConfig.rspack)), config;
 }
 async function unpackBuild(unpackConfig) {
-    let compiler = rspack(await getBundlerConfig(unpackConfig)), handler = (err, stats)=>{
+    let compiler = rspack(await getRspackConfig(unpackConfig)), handler = (err, stats)=>{
         if (err) {
             console.error(err.stack || err), err.details && console.error(err.details);
             return;
@@ -1797,7 +1586,7 @@ function execAsync(command, options) {
     });
 }
 async function unpackDev(unpackConfig) {
-    let compiler = rspack(await getBundlerConfig(unpackConfig)), port = await getPort(unpackConfig.server?.port), proxyConfig = unpackConfig.server?.proxy;
+    let compiler = rspack(await getRspackConfig(unpackConfig)), port = await getPort(unpackConfig.server?.port), proxyConfig = unpackConfig.server?.proxy;
     isPlainObject(proxyConfig) && (proxyConfig = Object.entries(proxyConfig).map(([contextStr, target])=>{
         let baseConfig = {
             context: contextStr.split(','),
@@ -1839,7 +1628,7 @@ async function unpackDev(unpackConfig) {
             ...middlewares
         ]);
     let server = new RspackDevServer(devServerOptions, compiler);
-    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v4.4.0`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
+    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v4.6.0`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
         port,
         host: unpackConfig.server.host,
         base: unpackConfig.base
@@ -1853,13 +1642,16 @@ async function unpackDev(unpackConfig) {
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "4.4.0",
+        version: "4.6.0",
         cachePath: 'node_modules/.unpack'
     }, resolveConfig = (mode)=>{
         let rootPath, outputPath, basePath, cachedTraceMap, fs, isValidMethodName, parseFrame, formatOriginalLocation, formatFullStack, resolveErrorLocationAndStack, root, alias, shouldTransformDeepImport, preJsAssets, jsAssets, cssAssets, bundledDepsCachePath, deepImportPkgPattern, deepImportRegex, plugin, root1, uno, generated, configOrPathFromUnpackConfig, defaultsFromUnpackConfig, VIRTUAL_UNO_CSS_ID, rootDir, isMpa, unoConfig, configFilePath, unpackConfigPath, tokens, requestedLayers, tasks, unocssCacheDir, tokensCachePath, layersCachePath, timeCachePath, configHashCachePath, generatedCachePath, bundlerCacheDir, cachedTokensSize, cachedLayersSize, isCompiling, resolveUnocssConfig, flushTasks, getVirtualModuleContent, hash, restoreSkipCode, applyUnoTransformers, optionsFromUnpackConfig, rootPath1, registerCode, namesCode, defaultConfig = {
             root: cwd,
             base: '/',
             sourceMap: 'production' !== mode && 'cheap-module-source-map',
+            splitChunks: {
+                preset: 'single-vendor'
+            },
             build: {
                 outDir: 'dist',
                 minify: !0,
@@ -1874,13 +1666,10 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                 mountId: 'root'
             },
             css: {
-                transformer: 'postcss',
+                transformer: 'lightningcss',
                 sourceMap: !1
             },
             performance: {
-                chunkSplit: {
-                    strategy: 'single-vendor'
-                },
                 printFileSize: !0
             },
             typeCheck: !0,
@@ -2434,9 +2223,6 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                         optimization: {
                                             splitChunks: !1
                                         },
-                                        experiments: {
-                                            css: !0
-                                        },
                                         externals: depExternals
                                     });
                                     compiler.run((_, stats)=>{
@@ -2518,7 +2304,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                             },
                             ...middlewares
                         ],
-                    bundlerConfig: (config)=>{
+                    rspackConfig: (config)=>{
                         let PLUGIN_NAME = 'InjectAssetsPlugin';
                         return config.plugins.push({
                             apply: (compiler)=>{
@@ -2614,7 +2400,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                             let configFile = node_path.join(root, file);
                             if (node_fs.existsSync(configFile)) return configFile;
                         }
-                    })(rootDir, configFilePath), configFromOption = mergeConfig(configFromOption, await loadConfigFromFile(configFilePath)), resolvedDefaults && (configFromOption = mergeConfig(resolvedDefaults, configFromOption)), configFromOption;
+                    })(rootDir, configFilePath), configFromOption = utils_mergeConfig(configFromOption, await loadConfigFromFile(configFilePath)), resolvedDefaults && (configFromOption = utils_mergeConfig(resolvedDefaults, configFromOption)), configFromOption;
                 }, flushTasks = async ()=>{
                     if (!tasks.length) return;
                     logger_logger.debug(colors.yellow(`[unocss] Extract token from ${tasks.length} modules.`));
@@ -2780,11 +2566,67 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     },
                     resolveId: (id)=>id.startsWith('virtual:svg-icons-') ? '\0' + id : null,
                     load: (id)=>'\0virtual:svg-icons-register' === id ? registerCode || 'export default null' : '\0virtual:svg-icons-names' === id ? namesCode || 'export default []' : null
-                })
+                }),
+                {
+                    name: 'unpack:split-chunks',
+                    rspackConfig (config, { unpackConfig, mergeConfig }) {
+                        if (!1 === unpackConfig.splitChunks) return mergeConfig(config, {
+                            optimization: {
+                                splitChunks: !1
+                            }
+                        });
+                        let { preset = 'none', ...rest } = unpackConfig.splitChunks;
+                        return mergeConfig(config, {
+                            optimization: {
+                                splitChunks: {
+                                    ...function(preset) {
+                                        if (!preset) return {};
+                                        switch(preset){
+                                            case 'single-vendor':
+                                                return {
+                                                    cacheGroups: {
+                                                        singleVendor: {
+                                                            test: NODE_MODULES_REGEX,
+                                                            priority: 0,
+                                                            chunks: 'all',
+                                                            name: 'vendor',
+                                                            enforce: !0
+                                                        }
+                                                    }
+                                                };
+                                            case 'per-package':
+                                                return {
+                                                    minSize: 0,
+                                                    maxInitialRequests: 1 / 0,
+                                                    cacheGroups: {
+                                                        vendors: {
+                                                            priority: -9,
+                                                            test: NODE_MODULES_REGEX,
+                                                            name: (module)=>module ? function(modulePath) {
+                                                                    let handleModuleContext = modulePath?.match(MODULE_PATH_REGEX);
+                                                                    if (!handleModuleContext) return;
+                                                                    let [, scope, name] = handleModuleContext;
+                                                                    return `npm-${scope ? `${scope.replace('@', '')}_` : ''}${name}`;
+                                                                }(module.context) : void 0
+                                                        }
+                                                    }
+                                                };
+                                            case 'none':
+                                                return {};
+                                            default:
+                                                throw Error(`Unknown splitChunks preset: ${preset}`);
+                                        }
+                                    }(preset),
+                                    ...rest
+                                }
+                            }
+                        });
+                    }
+                }
             ]
         };
         return {
-            ...mergeConfig(defaultConfig, userConfig),
+            ...utils_mergeConfig(defaultConfig, userConfig),
             _context
         };
     };
@@ -2793,7 +2635,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
             let mode = watch ? 'development' : 'production';
             setNodeEnv(mode);
             let config = resolveConfig(mode);
-            console.log(colors.brand(`${callerName} v4.4.0`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v4.6.0`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
             setUnpackStartTime(performance.now());
@@ -2824,8 +2666,10 @@ async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
 var injectFramework_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 async function injectFrameworkPluginForDebug(userConfig) {
     var plugin;
-    let raw, framework, framework1 = (raw = process.env.FRAMEWORK, (framework = raw?.trim().toLowerCase()) ? 'react' === framework || 'vue' === framework ? framework : (logger_logger.warn(`Unknown FRAMEWORK "${raw}", fallback to "react".`), 'react') : 'react'), pluginPath = node_path.resolve(injectFramework_dirname, `../../plugin-${framework1}/dist/index.js`);
-    node_fs.existsSync(pluginPath) && (plugin = (0, (await import(pluginPath))[`plugin${framework1.charAt(0).toUpperCase() + framework1.slice(1)}`])(), userConfig.plugins ? userConfig.plugins.unshift(plugin) : userConfig.plugins = [
+    let framework = process.env.FRAMEWORK?.trim();
+    if (!framework) return;
+    let pluginPath = node_path.resolve(injectFramework_dirname, `../../plugin-${framework}/dist/index.js`);
+    node_fs.existsSync(pluginPath) && (plugin = (0, (await import(pluginPath))[`plugin${framework.charAt(0).toUpperCase() + framework.slice(1)}`])(), userConfig.plugins ? userConfig.plugins.unshift(plugin) : userConfig.plugins = [
         plugin
     ]);
 }
@@ -2942,7 +2786,7 @@ function runCLI() {
             logger_logger.clear(), logger_logger.info(`${node_path.basename(file)} changed, restarting server...`), await watcher.close(), await cleanUpBeforeRestart(), startServer(options);
         });
     });
-    devCommand.option('-o, --open [url]', 'Open browser on startup').option('--port <port>', 'Specify port').option('--host', 'Expose hostname').action(startServer), cli.help(), cli.version("4.4.0"), cli.parse();
+    devCommand.option('-o, --open [url]', 'Open browser on startup').option('--port <port>', 'Specify port').option('--host', 'Expose hostname').action(startServer), cli.help(), cli.version("4.6.0"), cli.parse();
 }
 var src_CSS_MODULES_NAMED_EXPORT = !1;
-export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, applyHtmlTagDescriptors, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, emptyDir, ensureDir, esVersionToBrowserslist, external_tinyglobby_glob as glob, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getFilesContentHash, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, isBoolean, isDebug, isDev, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launchEditor, loadConfig, loadConfigFromFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, mergeConfig, normalizePublicPath, openBrowser, pLimit, pathExists, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, renderHtmlTagDescriptor, resolveConfigPath, rspack, runCLI, set, setCurrentUnpackConfig, setDevServer, setNodeEnv, setUnpackStartTime, src_CSS_MODULES_NAMED_EXPORT as CSS_MODULES_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd };
+export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, applyHtmlTagDescriptors, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, emptyDir, ensureDir, esVersionToBrowserslist, external_tinyglobby_glob as glob, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getFilesContentHash, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, isBoolean, isDebug, isDev, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launchEditor, loadConfig, loadConfigFromFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, normalizePublicPath, openBrowser, pLimit, pathExists, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, renderHtmlTagDescriptor, resolveConfigPath, rspack, runCLI, set, setCurrentUnpackConfig, setDevServer, setNodeEnv, setUnpackStartTime, src_CSS_MODULES_NAMED_EXPORT as CSS_MODULES_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd, utils_mergeConfig as mergeConfig };