@unpackjs/core 4.2.1 → 4.2.3

package/dist/index.js

@@ -10,6 +10,7 @@ import { Compilation, rspack } from "@rspack/core";
 import cac from "cac";
 import node_fs from "node:fs";
 import node_readline from "node:readline";
+import { createHash } from "node:crypto";
 import node_os, { platform } from "node:os";
 import portfinder from "portfinder";
 import { glob as external_tinyglobby_glob, globSync } from "tinyglobby";
@@ -17,7 +18,6 @@ import { format, promisify } from "node:util";
 import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import { parse } from "stacktrace-parser";
 import node_zlib from "node:zlib";
-import { createHash } from "node:crypto";
 import magic_string from "magic-string";
 import { expand } from "dotenv-expand";
 import node_assert from "node:assert";
@@ -122,7 +122,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: utils_mergeConfig } = __webpack_require__("compiled/webpack-merge"), { default: launchEditor } = __webpack_require__("compiled/launch-editor"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
+let { merge: 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';
@@ -169,7 +169,16 @@ function getTime() {
     let now = new Date(), hours = String(now.getHours()).padStart(2, '0'), minutes = String(now.getMinutes()).padStart(2, '0'), seconds = String(now.getSeconds()).padStart(2, '0');
     return `${hours}:${minutes}:${seconds}`;
 }
-let debounce = (fn, delay)=>{
+let getFilesContentHash = (filePaths)=>{
+    let normalizedPaths = [
+        ...filePaths
+    ].filter(Boolean).map((filePath)=>node_path.resolve(filePath)).sort(), hash = createHash('sha256');
+    for (let filePath of normalizedPaths.filter((filePath)=>node_fs.existsSync(filePath))){
+        let content = node_fs.readFileSync(filePath);
+        hash.update(content);
+    }
+    return hash.digest('hex');
+}, debounce = (fn, delay)=>{
     let timer = null;
     return (...args)=>{
         clearTimeout(timer), timer = setTimeout(()=>{
@@ -502,26 +511,75 @@ async function getCompressedSize(content) {
 let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|md)$/i, GLOB_MAGIC_RE = /[*?[\]{}()!@+|]/, normalizeBaseDir = (raw)=>{
     let normalized = raw.replace(/\\/g, '/');
     return normalized && '.' !== normalized ? (normalized.startsWith('/') ? normalized = normalized.replace(/\/{2,}/g, '/') : normalized.startsWith('.') || (normalized = `./${normalized}`), (normalized = normalized.replace(/\/{2,}/g, '/')).endsWith('/') && (normalized = normalized.slice(0, -1)), '.' === normalized ? './' : normalized) : './';
-}, toRegexLiteral = (source)=>`/${source.replace(/\\?\//g, (value)=>'/' === value ? '\\/' : value)}/`, parseGlob = (pattern)=>{
+}, toRegexLiteral = (source)=>`/${source.replace(/\\?\//g, (value)=>'/' === value ? '\\/' : value)}/`, buildInnerRegExpSource = (glob)=>{
+    let source = glob.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return (source = (source = source.replace(/\\\*\\\*/g, '.*')).replace(/\\\*/g, '[^/]*')).replace(/\\\?/g, '[^/]');
+}, parseGlob = (pattern)=>{
     let normalized = pattern.replace(/\\/g, '/'), isAbs = normalized.startsWith('/'), normalizedForParse = isAbs ? `.${normalized}` : normalized, globIndex = normalizedForParse.search(GLOB_MAGIC_RE), slashIndex = -1 === globIndex ? normalizedForParse.lastIndexOf('/') : normalizedForParse.lastIndexOf('/', globIndex), baseDirRaw = slashIndex >= 0 ? normalizedForParse.slice(0, slashIndex) : '.', globPart = slashIndex >= 0 ? normalizedForParse.slice(slashIndex + 1) : normalizedForParse, recursive = normalizedForParse.includes('**'), baseDir = isAbs ? normalizeBaseDir(`/${baseDirRaw.replace(/^\.\//, '')}`) : normalizeBaseDir(baseDirRaw);
     return {
         baseDir,
         regExpSource: ((glob)=>{
             let expansions;
             if (!glob) return '^\\.\\/.*$';
-            let { replaced, expansions: expansions1 } = (expansions = [], {
-                replaced: glob.replace(/\{([^}]+)\}/g, (_, inner)=>(expansions.push(inner), `__BRACE_${expansions.length - 1}__`)),
+            let { replaced: replacedExtGlob, negations } = ((glob)=>{
+                let negations = [], out = '';
+                for(let i = 0; i < glob.length; i++){
+                    let ch = glob[i];
+                    if ('!' !== ch || '(' !== glob[i + 1]) {
+                        out += ch;
+                        continue;
+                    }
+                    let j = i + 2, depth = 1;
+                    for(; j < glob.length; j++){
+                        let cj = glob[j];
+                        if ('(' === cj) depth++;
+                        else if (')' === cj && 0 == --depth) break;
+                    }
+                    if (0 !== depth) {
+                        out += ch;
+                        continue;
+                    }
+                    let inner = glob.slice(i + 2, j);
+                    negations.push(inner), out += `__EXT_NEG_${negations.length - 1}__`, i = j;
+                }
+                return {
+                    replaced: out,
+                    negations
+                };
+            })(glob), { replaced, expansions: expansions1 } = (expansions = [], {
+                replaced: replacedExtGlob.replace(/\{([^}]+)\}/g, (_, inner)=>(expansions.push(inner), `__BRACE_${expansions.length - 1}__`)),
                 expansions
             }), source = replaced.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            return source = (source = (source = (source = (source = (source = source.replace(/__BRACE_(\d+)__/g, (_, index)=>{
+            return source = (source = (source = (source = (source = (source = (source = source.replace(/__BRACE_(\d+)__/g, (_, index)=>{
                 let parts = (expansions1[Number(index)] || '').split(',').map((part)=>part.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
                 return `(${parts.join('|')})`;
+            })).replace(/__EXT_NEG_(\d+)__/g, (_, index)=>{
+                let parts = (negations[Number(index)] || '').split('|').map((part)=>part.trim()).filter(Boolean).map(buildInnerRegExpSource);
+                return parts.length ? `(?!(?:${parts.join('|')}))[^/]*` : '[^/]*';
             })).replace(/\\\(([^)]+)\\\)\\\?/g, (_, inner)=>`(?:${inner})?`)).replace(/\\\*\\\*\\\//g, '(?:.*\\/)?')).replace(/\\\*\\\*/g, '.*')).replace(/\\\*/g, '[^/]*')).replace(/\\\?/g, '[^/]'), `^(?:\\.\\/)?${source}$`;
         })(globPart),
         recursive,
         publicPrefix: './' === baseDir ? './' : baseDir
     };
-}, hasEager = (rawOptions)=>!!rawOptions && /eager\s*:\s*true/.test(rawOptions), SPECIAL_NO_ENTRY_DEPS = [
+}, hasEager = (rawOptions)=>!!rawOptions && /eager\s*:\s*true/.test(rawOptions), warnedMissingAliasKeys = new Set(), normalizeGlobByAliases = (pattern, options)=>{
+    let trimmed = pattern.trim();
+    if (!trimmed || trimmed.startsWith('/') || trimmed.startsWith('.')) return trimmed;
+    let aliasEntries = Object.entries(options.alias).filter(([key])=>key && '/' !== key).sort((a, b)=>b[0].length - a[0].length);
+    for (let [rawKey, rawTarget] of aliasEntries){
+        let key = rawKey.endsWith('/') ? rawKey.slice(0, -1) : rawKey;
+        if (!key || !trimmed.startsWith(`${key}/`)) continue;
+        let targetAbs = node_path.isAbsolute(rawTarget) ? rawTarget : node_path.resolve(options.root, rawTarget), rel = node_path.relative(options.root, targetAbs).replace(/\\/g, '/');
+        if (rel.startsWith('..')) continue;
+        let publicBase = `/${rel}`.replace(/\/{2,}/g, '/').replace(/\/$/, ''), rest = trimmed.slice(key.length);
+        return `${publicBase}${rest}`.replace(/\/{2,}/g, '/');
+    }
+    let normalized = trimmed.replace(/\\/g, '/'), firstChar = normalized[0];
+    if ('@' === firstChar || '~' === firstChar || '#' === firstChar) {
+        let slashIndex = normalized.indexOf('/'), aliasKey = normalized.slice(0, slashIndex);
+        aliasEntries.map(([rawKey])=>rawKey.endsWith('/') ? rawKey.slice(0, -1) : rawKey).filter(Boolean).includes(aliasKey) || warnedMissingAliasKeys.has(aliasKey) || (warnedMissingAliasKeys.add(aliasKey), logger_logger.warn(`Unrecognized alias "${aliasKey}" in glob pattern: "${trimmed}", please ensure it is defined in "resolve.alias".`));
+    }
+    return trimmed;
+}, SPECIAL_NO_ENTRY_DEPS = [
     '@iconify-icons/material-symbols'
 ], FRAMEWORKS = [
     'react',
@@ -564,7 +622,7 @@ let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|
     'uno.config.ts',
     'uno.config.js',
     'uno.config.mts'
-], LAYER_MARK_ALL = '__ALL__', HASH_PLACEHOLDER_RE = /#--unocss-hash--\s*\{\s*content\s*:\s*\\*"([^\\"]+)\\*";?\s*\}/g, LAYER_PLACEHOLDER_RE = /#--unocss--\s*\{\s*layer\s*:\s*(.+?)\s*(?:;\s*escape-view\s*:\s*(.+?)\s*)?;?\s*\}/g, SKIP_START_COMMENT = '@unocss-skip-start', SKIP_END_COMMENT = '@unocss-skip-end', SKIP_COMMENT_RE = RegExp(`(?://\\s*?${SKIP_START_COMMENT}\\s*?|/\\*\\s*?${SKIP_START_COMMENT}\\s*?\\*/|<!--\\s*?${SKIP_START_COMMENT}\\s*?-->)[\\s\\S]*?(?://\\s*?${SKIP_END_COMMENT}\\s*?|/\\*\\s*?${SKIP_END_COMMENT}\\s*?\\*/|<!--\\s*?${SKIP_END_COMMENT}\\s*?-->)`, 'g'), getCssEscaperForJsContent = (view)=>{
+], LAYER_MARK_ALL = '__ALL__', HASH_PLACEHOLDER_RE = /#--unocss-hash--\s*\{\s*content\s*:\s*\\*"([^\\"]+)\\*";?\s*\}/g, LAYER_PLACEHOLDER_RE = /#--unocss--\s*\{\s*layer\s*:\s*(.+?)\s*(?:;\s*escape-view\s*:\s*(.+?)\s*)?;?\s*\}/g, SKIP_START_COMMENT = '@unocss-skip-start', SKIP_END_COMMENT = '@unocss-skip-end', SKIP_COMMENT_RE = RegExp(`(?://\\s*?${SKIP_START_COMMENT}\\s*?|/\\*\\s*?${SKIP_START_COMMENT}\\s*?\\*/|<!--\\s*?${SKIP_START_COMMENT}\\s*?-->)[\\s\\S]*?(?://\\s*?${SKIP_END_COMMENT}\\s*?|/\\*\\s*?${SKIP_END_COMMENT}\\s*?\\*/|<!--\\s*?${SKIP_END_COMMENT}\\s*?-->)`, 'g'), LAYER_IMPORT_RE = /(['"])uno:([^'"]+?)\.css\1/g, getCssEscaperForJsContent = (view)=>{
     if (!view) return (css)=>css;
     let prefix = {};
     return view.trim().replace(/(\\*)\\(["'`\\])/g, (_, bs, char)=>(prefix[char] = bs.replace(/\\\\/g, '\\'), '')), (css)=>css.replace(/["'`\\]/g, (v)=>(prefix[v] || '') + v);
@@ -680,7 +738,7 @@ 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 utils_mergeConfig(config, {
+    return mergeConfig(config, {
         cache: !0,
         experiments: {
             cache: {
@@ -781,7 +839,7 @@ let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\
 };
 async function getEntry(root, customEntry) {
     let entry;
-    if (entry = customEntry ? node_path.resolve(root, customEntry) : (await external_tinyglobby_glob('(index|Index).{js,ts,jsx,tsx}', {
+    if (entry = customEntry ? node_path.resolve(root, customEntry) : (await external_tinyglobby_glob('(index|main).{js,ts,jsx,tsx}', {
         cwd: node_path.join(root, 'src'),
         absolute: !0
     }))[0], !node_fs.existsSync(entry)) throw Error('could not find entry file');
@@ -823,7 +881,7 @@ class JsMinifyPlugin {
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "4.2.1",
+            version: "4.2.3",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -968,31 +1026,18 @@ let registerHooks_PLUGIN_NAME = 'RegisterHooksPlugin';
 class RegisterHooksPlugin {
     isFirstCompile = !0;
     lastVirtualModules = new Map();
+    isCompiling = !1;
+    idleTimer = void 0;
     apply(compiler) {
         let virtualModulesPlugin = new rspack.experiments.VirtualModulesPlugin();
-        virtualModulesPlugin.apply(compiler), compiler.hooks.beforeCompile.tapPromise(registerHooks_PLUGIN_NAME, async ()=>{
-            await applyPluginsByHook('buildStart', async (impl)=>{
-                await impl({
+        virtualModulesPlugin.apply(compiler), compiler.hooks.compile.tap(registerHooks_PLUGIN_NAME, ()=>{
+            this.isCompiling = !0, applyPluginsByHookSync('buildStart', (impl)=>{
+                impl({
                     compiler,
                     isFirstCompile: this.isFirstCompile,
                     isWatch: isDev()
                 });
             });
-        }), compiler.hooks.done.tapPromise(registerHooks_PLUGIN_NAME, async (stats)=>{
-            stats?.compilation && ((compilation)=>{
-                let pluginMap = transformTimingMap.get(compilation);
-                if (pluginMap) {
-                    for (let [pluginName, total] of pluginMap)logger_logger.debug(`${colors.magenta('[plugin]')} ${colors.cyan(pluginName)} ${colors.blue('transform')} ${colors.dim('in')} ${colors.yellow(`${total.toFixed(2)}ms`)}`);
-                    transformTimingMap.delete(compilation);
-                }
-            })(stats.compilation), await applyPluginsByHook('buildEnd', async (impl)=>{
-                await impl({
-                    compiler,
-                    isFirstCompile: this.isFirstCompile,
-                    isWatch: isDev(),
-                    stats
-                });
-            }), this.isFirstCompile = !1;
         });
         let updateVirtualModules = ()=>{
             applyPluginsByHookSync('virtualModules', (impl)=>{
@@ -1001,15 +1046,7 @@ class RegisterHooksPlugin {
                 });
             });
         };
-        compiler.hooks.afterDone.tap(registerHooks_PLUGIN_NAME, ()=>{
-            isDev() && setTimeout(()=>{
-                updateVirtualModules();
-            }, 100);
-        }), compiler.hooks.compilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
-            rspack.HtmlRspackPlugin.getCompilationHooks(compilation).beforeEmit.tapPromise(registerHooks_PLUGIN_NAME, async (data)=>(await applyPluginsByHook('transformHtml', async (impl)=>{
-                    data.html = await impl(data.html);
-                }), data));
-        }), compiler.hooks.thisCompilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
+        compiler.hooks.thisCompilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
             updateVirtualModules(), applyPluginsByHook('processAssets', (impl, plugin)=>{
                 let { stage, handler } = impl;
                 compilation.hooks.processAssets.tapPromise({
@@ -1030,6 +1067,29 @@ class RegisterHooksPlugin {
                     }
                 });
             });
+        }), compiler.hooks.compilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
+            rspack.HtmlRspackPlugin.getCompilationHooks(compilation).beforeEmit.tapPromise(registerHooks_PLUGIN_NAME, async (data)=>(await applyPluginsByHook('transformHtml', async (impl)=>{
+                    data.html = await impl(data.html);
+                }), data));
+        }), compiler.hooks.finishMake.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
+            let pluginMap = transformTimingMap.get(compilation);
+            if (pluginMap) {
+                for (let [pluginName, total] of pluginMap)logger_logger.debug(`${colors.magenta('[plugin]')} ${colors.cyan(pluginName)} ${colors.blue('transform')} ${colors.dim('in')} ${colors.yellow(`${total.toFixed(2)}ms`)}`);
+                transformTimingMap.delete(compilation);
+            }
+        }), compiler.hooks.done.tapPromise(registerHooks_PLUGIN_NAME, async (stats)=>{
+            await applyPluginsByHook('buildEnd', async (impl)=>{
+                await impl({
+                    compiler,
+                    isFirstCompile: this.isFirstCompile,
+                    isWatch: isDev(),
+                    stats
+                });
+            }), this.isFirstCompile = !1;
+        }), compiler.hooks.afterDone.tap(registerHooks_PLUGIN_NAME, ()=>{
+            this.isCompiling = !1, isDev() && (clearTimeout(this.idleTimer), this.idleTimer = setTimeout(()=>{
+                this.isCompiling || updateVirtualModules();
+            }, 50));
         });
     }
 }
@@ -1069,7 +1129,7 @@ async function getBundlerConfig(originalUnpackConfig) {
     await applyPluginsByHook('config', async (impl)=>{
         rest = await impl(rest, {
             ...originalUnpackConfig._context,
-            mergeConfig: utils_mergeConfig
+            mergeConfig: mergeConfig
         });
     });
     let unpackConfig = {
@@ -1080,7 +1140,7 @@ async function getBundlerConfig(originalUnpackConfig) {
     setCurrentUnpackConfig(unpackConfig), await applyPluginsByHook('configResolved', async (impl)=>{
         await impl(unpackConfig, originalUnpackConfig._context);
     });
-    let tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTs = node_fs.existsSync(tsconfigPath), minifyOptions = isPlainObject(unpackConfig.build?.minify) ? unpackConfig.build?.minify : {}, { publicVars, filePaths: envFilePaths } = function({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
+    let tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTS = node_fs.existsSync(tsconfigPath), minifyOptions = isPlainObject(unpackConfig.build?.minify) ? unpackConfig.build?.minify : {}, { publicVars, filePaths: envFilePaths } = function({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
         'PUBLIC_'
     ], processEnv = process.env } = {}) {
         if ('local' === mode) throw Error(`${colors.yellow('local')} cannot be used as a value for env mode, because ${colors.yellow('.env.local')} represents a temporary local file. Please use another value.`);
@@ -1197,11 +1257,11 @@ async function getBundlerConfig(originalUnpackConfig) {
         ].filter(Boolean),
         externals: unpackConfig.externals,
         resolve: {
-            tsConfig: isTs ? tsconfigPath : void 0,
-            alias: {
-                '@': node_path.resolve(unpackConfig.root, 'src'),
-                ...unpackConfig.resolve?.alias
-            },
+            tsConfig: isTS ? {
+                configFile: tsconfigPath,
+                references: 'auto'
+            } : void 0,
+            alias: unpackConfig.resolve?.alias,
             extensionAlias: {
                 '.js': [
                     '.js',
@@ -1214,12 +1274,13 @@ async function getBundlerConfig(originalUnpackConfig) {
                 ]
             },
             extensions: [
-                '.tsx',
                 '.ts',
-                '.jsx',
+                '.tsx',
+                '.mjs',
                 '.js',
-                '.wasm',
+                '.jsx',
                 '.json',
+                '.wasm',
                 ...unpackConfig.resolve?.extensions || []
             ]
         },
@@ -1236,12 +1297,12 @@ async function getBundlerConfig(originalUnpackConfig) {
             moduleIds: isDev() ? 'named' : 'deterministic',
             minimize: !!unpackConfig.build?.minify && utils_isProd(),
             minimizer: [
-                new JsMinifyPlugin(utils_mergeConfig({
+                new JsMinifyPlugin(mergeConfig({
                     compress: {
                         target: unpackConfig.build.target
                     }
                 }, minifyOptions.oxc || {})),
-                new rspack.LightningCssMinimizerRspackPlugin(utils_mergeConfig({
+                new rspack.LightningCssMinimizerRspackPlugin(mergeConfig({
                     minimizerOptions: {
                         targets: esVersionToBrowserslist(unpackConfig.build.target)
                     }
@@ -1339,7 +1400,7 @@ async function getBundlerConfig(originalUnpackConfig) {
                     type: 'css/module'
                 }), getLessLoader = ()=>({
                     loader: getCompiledPkgPath('less-loader'),
-                    options: utils_mergeConfig({
+                    options: mergeConfig({
                         lessOptions: {
                             javascriptEnabled: !0
                         },
@@ -1484,7 +1545,7 @@ async function getBundlerConfig(originalUnpackConfig) {
                     getCssLoader(),
                     {
                         loader: getCompiledPkgPath('less-loader'),
-                        options: utils_mergeConfig({
+                        options: mergeConfig({
                             lessOptions: {
                                 javascriptEnabled: !0
                             },
@@ -1537,7 +1598,7 @@ async function getBundlerConfig(originalUnpackConfig) {
     })), unpackConfig.performance?.buildAnalyze && utils_isProd() && (config = await applyBuildAnalyzeConfig({
         config,
         unpackConfig
-    })), unpackConfig.typeCheck && isDev() && isTs && (config = await applyTypeCheckConfig({
+    })), unpackConfig.typeCheck && isDev() && isTS && (config = await applyTypeCheckConfig({
         config,
         unpackConfig
     })), unpackConfig.detectCircular && (config = function({ config, unpackConfig }) {
@@ -1577,11 +1638,11 @@ async function getBundlerConfig(originalUnpackConfig) {
         config = await impl(config, {
             ...originalUnpackConfig._context,
             unpackConfig,
-            mergeConfig: utils_mergeConfig
+            mergeConfig: mergeConfig
         });
     }), unpackConfig.bundlerConfig && (config = isFunction(unpackConfig.bundlerConfig) ? await unpackConfig.bundlerConfig(config, {
-        mergeConfig: utils_mergeConfig
-    }) : utils_mergeConfig(config, unpackConfig.bundlerConfig)), config;
+        mergeConfig: mergeConfig
+    }) : mergeConfig(config, unpackConfig.bundlerConfig)), config;
 }
 async function unpackBuild(unpackConfig) {
     let compiler = rspack(await getBundlerConfig(unpackConfig)), handler = (err, stats)=>{
@@ -1702,7 +1763,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.2.1`)}  ${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.2.3`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
         port,
         host: unpackConfig.server.host,
         base: unpackConfig.base
@@ -1716,10 +1777,10 @@ async function unpackDev(unpackConfig) {
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "4.2.1",
+        version: "4.2.3",
         cachePath: 'node_modules/.unpack'
     }, resolveConfig = (mode)=>{
-        let rootPath, outputPath, basePath, cachedTraceMap, fs, isValidMethodName, parseFrame, formatOriginalLocation, formatFullStack, resolveErrorLocationAndStack, shouldTransformDeepImport, preJsAssets, jsAssets, cssAssets, bundledDepsCachePath, deepImportPkgPattern, deepImportRegex, plugin, root, uno, configFilePath, configOrPathFromUnpackConfig, defaultsFromUnpackConfig, compilerRef, rootDir, unoConfig, tokens, unocssCacheDir, tokensCachePath, timeCachePath, layersCachePath, bundlerCacheDir, cachedTokensLength, cachedLayersLength, tasks, requestedLayers, layerImportRE, ensureReady, invalidate, flushTasks, getVirtualModuleContent, hash, restoreSkipCode, applyUnoTransformers, getResolvedLayers, optionsFromUnpackConfig, rootPath1, registerCode, namesCode, defaultConfig = {
+        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, getCustomLayers, optionsFromUnpackConfig, rootPath1, registerCode, namesCode, defaultConfig = {
             root: cwd,
             base: '/',
             sourceMap: 'production' !== mode && 'cheap-module-source-map',
@@ -1863,7 +1924,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                 }, {
                     name: 'unpack:browser-logs',
                     apply: (config, { command })=>'dev' === command && config.dev?.browserLogs,
-                    buildStart: async ({ isFirstCompile, compiler })=>{
+                    buildStart: ({ isFirstCompile, compiler })=>{
                         isFirstCompile && (fs = compiler.outputFileSystem);
                     },
                     configResolved: (config)=>{
@@ -2022,8 +2083,11 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                             ...middlewares
                         ]
                 }),
-                {
+                (root = '', alias = {}, {
                     name: 'unpack:glob',
+                    configResolved: (config)=>{
+                        root = config.root, alias = config.resolve?.alias || {};
+                    },
                     transform: {
                         filter: {
                             test: JS_REGEX
@@ -2042,10 +2106,10 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                         excludes
                                     });
                                     return includes1.length ? (({ includes, excludes, eager })=>{
-                                        let excludeMatchers = excludes.map((item)=>toRegexLiteral(item.regExpSource)).join(', '), includeItems = includes.map((item)=>{
+                                        let excludeMatchers = excludes.map((item)=>toRegexLiteral(item.regExpSource)).join(', '), modeExpr = eager ? 'sync' : 'lazy', includeItems = includes.map((item)=>{
                                             let prefix = './' === item.publicPrefix ? '' : `${item.publicPrefix}/`, mapKeyExpr = './' === item.publicPrefix ? "key.startsWith('./') ? key : './' + key" : `${JSON.stringify(prefix)} + (key.startsWith('./') ? key.slice(2) : key)`;
                                             return `{
-    context: import.meta.webpackContext(${JSON.stringify(item.baseDir)}, { recursive: ${item.recursive}, regExp: ${toRegexLiteral(item.regExpSource)} }),
+    context: import.meta.webpackContext(${JSON.stringify(item.baseDir)}, { recursive: ${item.recursive}, regExp: ${toRegexLiteral(item.regExpSource)}, mode: ${JSON.stringify(modeExpr)} }),
     mapKey: (key) => ${mapKeyExpr}
   }`;
                                         }).join(', '), excludeList = excludeMatchers ? `[${excludeMatchers}]` : '[]';
@@ -2059,27 +2123,36 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
       const path = mapKey(key)
       if (isExcluded(path)) continue
       if (!modules[path]) {
-        modules[path] = ${eager ? 'context(key)' : '() => Promise.resolve(context(key))'}
+        modules[path] = ${eager ? 'context(key)' : '() => context(key)'}
       }
     }
   }
   return modules
 })()`;
                                     })({
-                                        includes: includes1.map(parseGlob),
-                                        excludes: excludes1.map(parseGlob),
+                                        includes: includes1.map((p)=>normalizeGlobByAliases(p, {
+                                                root,
+                                                alias
+                                            })).map(parseGlob),
+                                        excludes: excludes1.map((p)=>normalizeGlobByAliases(p, {
+                                                root,
+                                                alias
+                                            })).map(parseGlob),
                                         eager: hasEager(rawOptions)
                                     }) : '({})';
                                 }
-                                let { baseDir, regExpSource, recursive, publicPrefix } = parseGlob(pattern);
+                                let { baseDir, regExpSource, recursive, publicPrefix } = parseGlob(normalizeGlobByAliases(pattern, {
+                                    root,
+                                    alias
+                                }));
                                 return (({ baseDir, regExpSource, recursive, eager, publicPrefix })=>{
                                     let prefix = './' === publicPrefix ? '' : `${publicPrefix}/`, mapKeyExpr = './' === publicPrefix ? "key.startsWith('./') ? key : './' + key" : `${JSON.stringify(prefix)} + (key.startsWith('./') ? key.slice(2) : key)`;
                                     return `(() => {
-  const context = import.meta.webpackContext(${JSON.stringify(baseDir)}, { recursive: ${recursive}, regExp: ${toRegexLiteral(regExpSource)} })
+  const context = import.meta.webpackContext(${JSON.stringify(baseDir)}, { recursive: ${recursive}, regExp: ${toRegexLiteral(regExpSource)}, mode: ${JSON.stringify(eager ? 'sync' : 'lazy')} })
   const modules = {}
   for (const key of context.keys()) {
     const path = ${mapKeyExpr}
-    modules[path] = ${eager ? 'context(key)' : '() => Promise.resolve(context(key))'}
+    modules[path] = ${eager ? 'context(key)' : '() => context(key)'}
   }
   return modules
 })()`;
@@ -2092,7 +2165,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                 });
                             }) : null
                     }
-                },
+                }),
                 (shouldTransformDeepImport = !1, preJsAssets = [], jsAssets = [], cssAssets = [], bundledDepsCachePath = '', deepImportPkgPattern = [
                     ...SPECIAL_NO_ENTRY_DEPS
                 ].sort((a, b)=>b.length - a.length).map((name)=>name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), deepImportRegex = RegExp(`import\\s+([a-zA-Z0-9_$]+)\\s+from\\s+['"]((${deepImportPkgPattern})/[^'"]+)['"]`, 'g'), plugin = {
@@ -2370,11 +2443,11 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                         }), config;
                     }
                 }),
-                (root = '', {
+                (root1 = '', {
                     name: 'unpack:file-size',
                     apply: (config, { mode })=>'production' === mode && config.performance?.printFileSize,
                     configResolved (config) {
-                        root = config.root;
+                        root1 = config.root;
                     },
                     buildEnd: async (options)=>{
                         let { stats } = options;
@@ -2400,7 +2473,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                 color: 'cyan',
                                 chunks: []
                             }
-                        ], chunkGroupMap = chunkGroups.reduce((acc, cur)=>(acc[cur.type] = cur, acc), {}), distPath = stats.compilation.outputOptions.path, distFolder = node_path.relative(root, distPath), assets = Object.entries(stats.compilation.assets), longest = 0, totalSize = 0, totalCompressedSize = 0;
+                        ], chunkGroupMap = chunkGroups.reduce((acc, cur)=>(acc[cur.type] = cur, acc), {}), distPath = stats.compilation.outputOptions.path, distFolder = node_path.relative(root1, distPath), assets = Object.entries(stats.compilation.assets), longest = 0, totalSize = 0, totalCompressedSize = 0;
                         logUpdate('computing gzip size...'), await Promise.all(assets.map(async ([assetName, value])=>{
                             let content, compressedSize, filePath = assetName.split('?')[0];
                             try {
@@ -2442,34 +2515,27 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                         log += colors.blue(displaySize(totalSize)), console.log(log += colors.dim(` │ gzip: ${displaySize(totalCompressedSize)}`));
                     }
                 }),
-                (rootDir = process.cwd(), unoConfig = {}, tokens = new Set(), unocssCacheDir = '', tokensCachePath = '', timeCachePath = '', layersCachePath = '', bundlerCacheDir = '', cachedTokensLength = 0, cachedLayersLength = 0, tasks = [], requestedLayers = new Set([
+                (VIRTUAL_UNO_CSS_ID = 'uno.css', rootDir = process.cwd(), isMpa = !1, unoConfig = {}, configFilePath = '', unpackConfigPath = '', tokens = new Set(), requestedLayers = new Set([
                     LAYER_MARK_ALL
-                ]), layerImportRE = /(['"])uno:([^'"]+?)\.css\1/g, ensureReady = async ()=>{
-                    var root, configOrPath;
-                    let core = await import("@unocss/core"), resolvedConfigOrPath = (root = rootDir, 'string' != typeof (configOrPath = (void 0) ?? configOrPathFromUnpackConfig) || node_path.isAbsolute(configOrPath) ? configOrPath : node_path.resolve(root, configOrPath)), resolvedDefaults = (void 0) ?? defaultsFromUnpackConfig, configFromOption = {};
-                    if (isPlainObject(resolvedConfigOrPath) ? configFromOption = resolvedConfigOrPath : isString(resolvedConfigOrPath) && (configFilePath = resolvedConfigOrPath), configFilePath || (configFilePath = ((root, customConfig)=>{
+                ]), tasks = [], unocssCacheDir = '', tokensCachePath = '', layersCachePath = '', timeCachePath = '', configHashCachePath = '', generatedCachePath = '', bundlerCacheDir = '', cachedTokensSize = 0, cachedLayersSize = 0, isCompiling = !0, resolveUnocssConfig = async ()=>{
+                    let resolvedConfigOrPath = (void 0) ?? configOrPathFromUnpackConfig, resolvedDefaults = (void 0) ?? defaultsFromUnpackConfig, configFromOption = {};
+                    return isPlainObject(resolvedConfigOrPath) ? configFromOption = resolvedConfigOrPath : isString(resolvedConfigOrPath) && (configFilePath = node_path.isAbsolute(resolvedConfigOrPath) ? resolvedConfigOrPath : node_path.resolve(rootDir, resolvedConfigOrPath)), configFilePath = ((root, customConfig)=>{
+                        if (customConfig) {
+                            let absPath = node_path.isAbsolute(customConfig) ? customConfig : node_path.resolve(root, customConfig);
+                            if (node_fs.existsSync(absPath)) return absPath;
+                        }
                         for (let file of UNOCSS_CONFIG_FILES){
                             let configFile = node_path.join(root, file);
                             if (node_fs.existsSync(configFile)) return configFile;
                         }
-                    })(rootDir)), configFilePath && node_fs.existsSync(configFilePath) && (configFromOption = utils_mergeConfig(configFromOption, await loadConfigFile(configFilePath))), resolvedDefaults && (configFromOption = utils_mergeConfig(resolvedDefaults, configFromOption)), unoConfig = configFromOption, uno = await core.createGenerator(unoConfig), tokens = new Set(), node_fs.existsSync(tokensCachePath)) {
-                        let cached = JSON.parse(node_fs.readFileSync(tokensCachePath, 'utf-8'));
-                        Array.isArray(cached) && (cachedTokensLength = (tokens = new Set(cached)).size, logger_logger.debug(colors.yellow(`[unocss] Load ${tokens.size} token from cache.`)));
-                    }
-                    if (node_fs.existsSync(layersCachePath)) {
-                        let cached = JSON.parse(node_fs.readFileSync(layersCachePath, 'utf-8'));
-                        Array.isArray(cached) && (cachedLayersLength = (requestedLayers = new Set(cached)).size, logger_logger.debug(colors.yellow(`[unocss] Load ${requestedLayers.size} layer from cache.`)));
-                    }
-                }, invalidate = ()=>{
-                    setTimeout(()=>{
-                        compilerRef.watching.invalidate(), logger_logger.debug(colors.yellow('[unocss] Invalidation triggered.'));
-                    }, 0);
+                    })(rootDir, configFilePath), configFromOption = mergeConfig(configFromOption, await loadConfigFile(configFilePath)), resolvedDefaults && (configFromOption = mergeConfig(resolvedDefaults, configFromOption)), configFromOption;
                 }, flushTasks = async ()=>{
                     if (!tasks.length) return;
+                    logger_logger.debug(colors.yellow(`[unocss] Extract token from ${tasks.length} files.`));
                     let pending = tasks.map((t)=>t());
                     tasks = [], await Promise.all(pending);
                 }, getVirtualModuleContent = (layer)=>{
-                    let code, layersKey = Array.from(requestedLayers).sort().join(','), hash = (code = `${tokens.size}|${layer}|${layersKey}`, createHash('sha256').update(code).digest('hex').slice(0, 8));
+                    let code, hash = (code = `${tokens.size}|${layer}|${requestedLayers.size}`, createHash('sha256').update(code).digest('hex').slice(0, 8));
                     return `#--unocss-hash--{content:"${hash}"}#--unocss--{layer:${layer};escape-view:\\"\\'\\\`\\\\}`;
                 }, hash = (str)=>{
                     let i, l, hVal = 0x811c9dc5;
@@ -2494,50 +2560,74 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     for (let t of transformers)(!t.idFilter || t.idFilter(id)) && (await t.transform(s, id, {
                         uno,
                         tokens,
-                        invalidate
+                        invalidate: ()=>{}
                     }), s.hasChanged() && (s = new magic_string(code = restoreSkipCode(s.toString(), skipMap))));
                     return code !== original ? code : null;
-                }, getResolvedLayers = ()=>Array.from(requestedLayers).filter((layer)=>layer !== LAYER_MARK_ALL), {
+                }, getCustomLayers = ()=>Array.from(requestedLayers).filter((layer)=>layer !== LAYER_MARK_ALL), {
                     name: 'unpack:unocss',
-                    apply: (config)=>!!config.unocss,
+                    apply: (config)=>!!config.css?.unocss,
                     configResolved: async (config, { cachePath })=>{
-                        if (rootDir = config.root, unocssCacheDir = node_path.resolve(rootDir, cachePath, 'unocss'), tokensCachePath = node_path.resolve(unocssCacheDir, 'tokens'), timeCachePath = node_path.resolve(unocssCacheDir, 'created_at'), layersCachePath = node_path.resolve(unocssCacheDir, 'layers'), bundlerCacheDir = node_path.resolve(rootDir, cachePath, 'cache'), ensureDir(unocssCacheDir), (()=>{
-                            let now = Date.now(), last = 0;
-                            if (!node_fs.existsSync(timeCachePath)) {
-                                node_fs.writeFileSync(timeCachePath, String(now), 'utf-8'), emptyDir(bundlerCacheDir);
-                                return;
-                            }
-                            let parsed = Number(node_fs.readFileSync(timeCachePath, 'utf-8').trim());
-                            Number.isNaN(parsed) || (last = parsed), now - last < 604800000 || (emptyDir(unocssCacheDir), emptyDir(bundlerCacheDir), node_fs.writeFileSync(timeCachePath, String(now), 'utf-8'));
-                        })(), Array.isArray(config.unocss)) {
-                            let [configOrPathValue, defaultsValue] = config.unocss;
+                        if (rootDir = config.root, isMpa = !!config.mpa, unpackConfigPath = resolveConfigPath(rootDir), bundlerCacheDir = node_path.resolve(rootDir, cachePath, 'cache'), unocssCacheDir = node_path.resolve(rootDir, cachePath, 'unocss'), tokensCachePath = node_path.resolve(unocssCacheDir, 'tokens'), layersCachePath = node_path.resolve(unocssCacheDir, 'layers'), timeCachePath = node_path.resolve(unocssCacheDir, 'created_at'), configHashCachePath = node_path.resolve(unocssCacheDir, 'config_hash'), generatedCachePath = node_path.resolve(unocssCacheDir, 'generated'), Array.isArray(config.css?.unocss)) {
+                            let [configOrPathValue, defaultsValue] = config.css.unocss;
                             configOrPathFromUnpackConfig = configOrPathValue, defaultsFromUnpackConfig = defaultsValue;
                         }
-                        await ensureReady();
-                    },
-                    bundlerConfig: (config, { mergeConfig, unpackConfig })=>mergeConfig(config, {
-                            experiments: {
-                                cache: {
-                                    type: unpackConfig.performance?.cache ? 'persistent' : 'memory',
-                                    buildDependencies: configFilePath ? [
-                                        configFilePath
-                                    ] : void 0
+                        unoConfig = await resolveUnocssConfig();
+                        let core = await import("@unocss/core");
+                        uno = await core.createGenerator(unoConfig), (()=>{
+                            let now = Date.now(), nextHash = getFilesContentHash([
+                                configFilePath,
+                                unpackConfigPath
+                            ]);
+                            if (!node_fs.existsSync(unocssCacheDir)) {
+                                ensureDir(unocssCacheDir), node_fs.writeFileSync(timeCachePath, String(now), 'utf-8'), node_fs.writeFileSync(configHashCachePath, nextHash, 'utf-8'), removeDir(bundlerCacheDir);
+                                return;
+                            }
+                            let cachedTime = Number(node_fs.readFileSync(timeCachePath, 'utf-8').trim()), cachedHash = node_fs.readFileSync(configHashCachePath, 'utf-8').trim(), isExpired = now - cachedTime >= 604800000, isHashChanged = cachedHash !== nextHash;
+                            (isExpired || isHashChanged) && (isExpired && logger_logger.debug(colors.yellow('[unocss] Cache expired.')), isHashChanged && logger_logger.debug(colors.yellow('[unocss] Cache invalidated because config has changed.')), removeDir(unocssCacheDir), removeDir(bundlerCacheDir), ensureDir(unocssCacheDir), node_fs.writeFileSync(timeCachePath, String(now), 'utf-8'), node_fs.writeFileSync(configHashCachePath, nextHash, 'utf-8'));
+                        })(), (()=>{
+                            if (node_fs.existsSync(tokensCachePath)) {
+                                let cached = JSON.parse(node_fs.readFileSync(tokensCachePath, 'utf-8'));
+                                Array.isArray(cached) && (cachedTokensSize = (tokens = new Set(cached)).size, logger_logger.debug(colors.yellow(`[unocss] Load ${tokens.size} token from cache.`)));
+                            }
+                            if (node_fs.existsSync(layersCachePath)) {
+                                let cached = JSON.parse(node_fs.readFileSync(layersCachePath, 'utf-8'));
+                                Array.isArray(cached) && (cachedLayersSize = (requestedLayers = new Set(cached)).size, logger_logger.debug(colors.yellow(`[unocss] Load ${requestedLayers.size} layer from cache.`)));
+                            }
+                            if (node_fs.existsSync(generatedCachePath)) {
+                                let cached = JSON.parse(node_fs.readFileSync(generatedCachePath, 'utf-8'));
+                                if (cached && cached.meta?.tokensSize === tokens.size && cached.meta?.layersSize === requestedLayers.size) {
+                                    let list, index, runChunk, timer;
+                                    generated = cached, isDev() && (list = Array.from(tokens), index = 0, timer = setTimeout(runChunk = ()=>{
+                                        if (isCompiling) {
+                                            let timer = setTimeout(runChunk, 100);
+                                            timer.unref?.();
+                                            return;
+                                        }
+                                        let end = Math.min(index + 200, list.length);
+                                        for(; index < end; index++)uno.parseToken(list[index]);
+                                        if (logger_logger.debug(colors.yellow(`[unocss] Warmup tokens ${index}/${list.length}.`)), index < list.length) {
+                                            let timer = setTimeout(runChunk, 0);
+                                            timer.unref?.();
+                                        }
+                                    }, 0), timer.unref?.()), logger_logger.debug(colors.yellow('[unocss] Load generated css from cache.'));
                                 }
                             }
-                        }),
-                    buildStart ({ compiler }) {
-                        compilerRef = compiler;
+                        })();
+                    },
+                    buildStart () {
+                        isCompiling = !0;
                     },
                     buildEnd () {
-                        tokens.size !== cachedTokensLength && (node_fs.writeFileSync(tokensCachePath, JSON.stringify(Array.from(tokens)), 'utf-8'), logger_logger.debug(colors.yellow(`[unocss] Add ${tokens.size - cachedTokensLength} token to cache.`)), cachedTokensLength = tokens.size), requestedLayers.size !== cachedLayersLength && (node_fs.writeFileSync(layersCachePath, JSON.stringify(Array.from(requestedLayers)), 'utf-8'), logger_logger.debug(colors.yellow(`[unocss] Add ${requestedLayers.size - cachedLayersLength} layer to cache.`)), cachedLayersLength = requestedLayers.size);
+                        isCompiling = !1, tokens.size !== cachedTokensSize && (node_fs.writeFileSync(tokensCachePath, JSON.stringify(Array.from(tokens)), 'utf-8'), logger_logger.debug(colors.yellow(`[unocss] Add ${tokens.size - cachedTokensSize} token to cache.`)), cachedTokensSize = tokens.size), requestedLayers.size !== cachedLayersSize && (node_fs.writeFileSync(layersCachePath, JSON.stringify(Array.from(requestedLayers)), 'utf-8'), logger_logger.debug(colors.yellow(`[unocss] Add ${requestedLayers.size - cachedLayersSize} layer to cache.`)), cachedLayersSize = requestedLayers.size);
                     },
                     transform: {
                         filter: {
-                            test: /\.(vue|svelte|[jt]sx?|vine\.ts|mdx?|astro|elm|php|phtml|marko)($|\?)/
+                            test: /\.(vue|svelte|[jt]sx?|vine\.ts|mdx?|astro|elm|php|phtml|marko|css|scss|sass|less)($|\?)/
                         },
                         handler: async (code, id)=>{
                             var task;
-                            if (code.includes('uno:')) for (let match of code.matchAll(layerImportRE)){
+                            if (id.endsWith(VIRTUAL_UNO_CSS_ID) || /uno:[^?]+\.css(?:\?|$)/.test(id)) return null;
+                            if (code.includes('uno:')) for (let match of code.matchAll(LAYER_IMPORT_RE)){
                                 let layer = match[2];
                                 layer && requestedLayers.add(layer);
                             }
@@ -2555,26 +2645,35 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     processAssets: {
                         stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
                         handler: async ({ compilation, sources })=>{
-                            await flushTasks();
-                            let resolvedLayers = getResolvedLayers(), result = await uno.generate(tokens, {
-                                minify: !0
-                            });
+                            if (await flushTasks(), !generated || generated.meta.tokensSize !== tokens.size || generated.meta.layersSize !== requestedLayers.size) {
+                                let result = await uno.generate(tokens, {
+                                    minify: !0
+                                }), customLayers = getCustomLayers();
+                                generated = {
+                                    meta: {
+                                        tokensSize: tokens.size,
+                                        layersSize: requestedLayers.size
+                                    },
+                                    allCSS: result.getLayers(void 0, customLayers),
+                                    layerCSS: customLayers.reduce((acc, layer)=>(acc[layer] = result.getLayer(layer) || '', acc), {})
+                                }, node_fs.writeFileSync(generatedCachePath, JSON.stringify(generated), 'utf-8');
+                            }
                             for (let file of Object.keys(compilation.assets)){
-                                if ('*' === file || file.includes('vendor')) continue;
+                                if (!isMpa && !file.includes('main')) continue;
                                 let code = compilation.assets[file].source().toString();
                                 if (!code.includes('#--unocss')) continue;
                                 let isJsAsset = /\.(?:[cm]?js|[cm]?jsx)$/.test(file), replaced = !1;
                                 code = (code = code.replace(HASH_PLACEHOLDER_RE, '')).replace(LAYER_PLACEHOLDER_RE, (_, layer, escapeView)=>{
                                     replaced = !0;
-                                    let css = layer.trim() === LAYER_MARK_ALL ? result.getLayers(void 0, resolvedLayers) : result.getLayer(layer) || '';
+                                    let css = layer.trim() === LAYER_MARK_ALL ? generated.allCSS : generated.layerCSS[layer] || '';
                                     return isJsAsset ? getCssEscaperForJsContent(escapeView)(css) : css;
                                 }), replaced && compilation.updateAsset(file, new sources.RawSource(code));
                             }
                         }
                     },
                     virtualModules: ()=>({
-                            'uno.css': getVirtualModuleContent(LAYER_MARK_ALL),
-                            ...getResolvedLayers().reduce((acc, layer)=>(acc[`uno:${layer}.css`] = getVirtualModuleContent(layer), acc), {})
+                            [VIRTUAL_UNO_CSS_ID]: getVirtualModuleContent(LAYER_MARK_ALL),
+                            ...getCustomLayers().reduce((acc, layer)=>(acc[`uno:${layer}.css`] = getVirtualModuleContent(layer), acc), {})
                         })
                 }),
                 (rootPath1 = '', registerCode = '', namesCode = '', {
@@ -2610,7 +2709,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
             ]
         };
         return {
-            ...utils_mergeConfig(defaultConfig, userConfig),
+            ...mergeConfig(defaultConfig, userConfig),
             _context
         };
     };
@@ -2619,7 +2718,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.2.1`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v4.2.3`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
             setUnpackStartTime(performance.now());
@@ -2768,7 +2867,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.2.1"), 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.2.3"), 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, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, emptyDir, ensureDir, esVersionToBrowserslist, external_tinyglobby_glob as glob, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, injectToHead, isBoolean, isDebug, isDev, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launchEditor, loadConfig, loadConfigFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, normalizePublicPath, openBrowser, pLimit, pathExists, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, 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 };
+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, 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, injectToHead, isBoolean, isDebug, isDev, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launchEditor, loadConfig, loadConfigFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, mergeConfig, normalizePublicPath, openBrowser, pLimit, pathExists, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, 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 };