@unpackjs/core 4.2.0 → 4.2.2

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,11 +122,11 @@ 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';
-}, isDev = ()=>'development' === getNodeEnv(), utils_isDevServer = ()=>'true' === process.env.DEV_SERVER, isWatch = ()=>isDev() && !utils_isDevServer(), utils_isProd = ()=>'production' === getNodeEnv(), isWin = ()=>'win32' === process.platform, isString = (str)=>'string' == typeof str, isBoolean = (bool)=>'boolean' == typeof bool, isUndefined = (obj)=>void 0 === obj, isFunction = (func)=>'function' == typeof func, isObject = (obj)=>null !== obj && 'object' == typeof obj, isPlainObject = (obj)=>isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj), isRegExp = (obj)=>'[object RegExp]' === Object.prototype.toString.call(obj), prettyTime = (seconds)=>{
+}, isDev = ()=>'development' === getNodeEnv(), utils_isDevServer = ()=>'true' === process.env.DEV_SERVER, utils_isProd = ()=>'production' === getNodeEnv(), isWin = ()=>'win32' === process.platform, isString = (str)=>'string' == typeof str, isBoolean = (bool)=>'boolean' == typeof bool, isUndefined = (obj)=>void 0 === obj, isFunction = (func)=>'function' == typeof func, isObject = (obj)=>null !== obj && 'object' == typeof obj, isPlainObject = (obj)=>isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj), isRegExp = (obj)=>'[object RegExp]' === Object.prototype.toString.call(obj), prettyTime = (seconds)=>{
     let toFixed = (num, len)=>{
         let factor = 10 ** len;
         return Math.floor(num * factor) / factor;
@@ -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(()=>{
@@ -329,7 +338,25 @@ function getHtmlTemplateOrContent(rawTemplate, root) {
         templateContent
     };
 }
-let injectToHead = (html, script)=>html.replace(/<head(\s*[^>]*)>/i, (match)=>`${match}${script}`), logger_prefixes = {
+let injectToHead = (html, script)=>html.replace(/<head(\s*[^>]*)>/i, (match)=>`${match}${script}`), loadConfigFile = async (configFilePath)=>{
+    if (isNodeVersionAtLeast(22, 18) || /\.(?:js|mjs|cjs)$/.test(configFilePath)) {
+        logger_logger.debug('loading config file with native loader:', colors.dim(configFilePath));
+        let configFileURL = pathToFileURL(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
+        return exportModule.default ? exportModule.default : exportModule;
+    }
+    logger_logger.debug('loading config file with jiti:', colors.dim(configFilePath));
+    let { createJiti } = await import("jiti"), jiti = createJiti(import.meta.url, {
+        moduleCache: !1,
+        interopDefault: !0,
+        nativeModules: [
+            '@rspack/core',
+            "typescript"
+        ]
+    });
+    return await jiti.import(configFilePath, {
+        default: !0
+    });
+}, logger_prefixes = {
     wait: '○',
     error: '⨯',
     warn: '⚠',
@@ -370,36 +397,15 @@ let injectToHead = (html, script)=>html.replace(/<head(\s*[^>]*)>/i, (match)=>`$
         })(type, message, ...args);
     };
 }), logger);
-var config_filename = __rspack_fileURLToPath(import.meta.url);
 async function loadConfig({ cliOptions, command }) {
     'build' === command ? setNodeEnv(cliOptions?.watch ? 'development' : 'production') : (setNodeEnv('development'), setDevServer(!0));
     let root = cliOptions?.root ? node_path.resolve(cliOptions.root) : process.cwd(), configFilePath = resolveConfigPath(root, cliOptions?.config), configExport = {};
-    if (configFilePath) {
-        if (isNodeVersionAtLeast(22, 18) || /\.(?:js|mjs|cjs)$/.test(configFilePath)) {
-            logger_logger.debug('loading config file with native loader:', colors.dim(configFilePath));
-            let configFileURL = pathToFileURL(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
-            configExport = exportModule.default ? exportModule.default : exportModule;
-        } else {
-            logger_logger.debug('loading config file with jiti:', colors.dim(configFilePath));
-            let { createJiti } = await import("jiti"), jiti = createJiti(config_filename, {
-                moduleCache: !1,
-                interopDefault: !0,
-                nativeModules: [
-                    '@rspack/core',
-                    "typescript"
-                ]
-            });
-            configExport = await jiti.import(configFilePath, {
-                default: !0
-            });
-        }
-        if ('function' == typeof configExport) {
-            let params = {
-                env: getNodeEnv(),
-                command: process.argv[2]
-            };
-            if (void 0 === (configExport = await configExport(params))) throw Error('unpack config function must return a config object.');
-        }
+    if (configFilePath && 'function' == typeof (configExport = await loadConfigFile(configFilePath))) {
+        let params = {
+            env: getNodeEnv(),
+            command: process.argv[2]
+        };
+        if (void 0 === (configExport = await configExport(params))) throw Error('unpack config function must return a config object.');
     }
     let applyOption = (path, value)=>{
         void 0 !== value && set(configExport, path, value);
@@ -470,6 +476,18 @@ let removeDir = (dir)=>{
         recursive: !0,
         force: !0
     });
+}, emptyDir = (dir)=>{
+    if (!node_fs.existsSync(dir)) return void node_fs.mkdirSync(dir, {
+        recursive: !0
+    });
+    for (let file of node_fs.readdirSync(dir))node_fs.rmSync(node_path.join(dir, file), {
+        recursive: !0,
+        force: !0
+    });
+}, ensureDir = (dir)=>{
+    node_fs.existsSync(dir) || node_fs.mkdirSync(dir, {
+        recursive: !0
+    });
 }, restartCleaners = [], addRestartCleaner = (...cleaners)=>{
     restartCleaners.push(...cleaners);
 }, cleanUpBeforeRestart = async ()=>{
@@ -493,26 +511,69 @@ 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), normalizeGlobByAliases = (pattern, options)=>{
+    let trimmed = pattern.trim();
+    if (!trimmed || trimmed.startsWith('/') || trimmed.startsWith('.')) return trimmed;
+    for (let [rawKey, rawTarget] of Object.entries(options.alias).filter(([key])=>key && '/' !== key).sort((a, b)=>b[0].length - a[0].length)){
+        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, '/');
+    }
+    return trimmed;
+}, SPECIAL_NO_ENTRY_DEPS = [
     '@iconify-icons/material-symbols'
 ], FRAMEWORKS = [
     'react',
@@ -555,23 +616,7 @@ let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|
     'uno.config.ts',
     'uno.config.js',
     'uno.config.mts'
-], loadConfigFile = async (configFilePath)=>{
-    if (/\.(?:js|mjs)$/.test(configFilePath)) {
-        let configFileURL = pathToFileURL(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
-        return exportModule.default ? exportModule.default : exportModule;
-    }
-    let { createJiti } = await import("jiti"), jiti = createJiti(import.meta.url, {
-        moduleCache: !1,
-        interopDefault: !0,
-        nativeModules: [
-            '@rspack/core',
-            "typescript"
-        ]
-    });
-    return await jiti.import(configFilePath, {
-        default: !0
-    });
-}, 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);
@@ -687,7 +732,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: {
@@ -788,7 +833,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');
@@ -830,7 +875,7 @@ class JsMinifyPlugin {
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "4.2.0",
+            version: "4.2.2",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -974,46 +1019,29 @@ class ProgressPlugin extends rspack.ProgressPlugin {
 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: isWatch()
+                    isWatch: isDev()
                 });
             });
-        }), compiler.hooks.done.tapPromise(registerHooks_PLUGIN_NAME, async (stats)=>{
-            try {
-                await applyPluginsByHook('buildEnd', async (impl)=>{
-                    await impl({
-                        compiler,
-                        isFirstCompile: this.isFirstCompile,
-                        isWatch: isWatch(),
-                        stats
-                    });
-                });
-            } finally{
-                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);
-            }
-            this.isFirstCompile = !1;
-        }), 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)=>{
+        });
+        let updateVirtualModules = ()=>{
             applyPluginsByHookSync('virtualModules', (impl)=>{
                 Object.entries(impl()).forEach(([path, content])=>{
-                    virtualModulesPlugin.writeModule(path, content);
+                    this.lastVirtualModules.get(path) !== content && (this.lastVirtualModules.set(path, content), virtualModulesPlugin.writeModule(path, content));
                 });
-            }), applyPluginsByHook('processAssets', (impl, plugin)=>{
+            });
+        };
+        compiler.hooks.thisCompilation.tap(registerHooks_PLUGIN_NAME, (compilation)=>{
+            updateVirtualModules(), applyPluginsByHook('processAssets', (impl, plugin)=>{
                 let { stage, handler } = impl;
                 compilation.hooks.processAssets.tapPromise({
                     name: registerHooks_PLUGIN_NAME,
@@ -1033,6 +1061,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));
         });
     }
 }
@@ -1072,7 +1123,7 @@ async function getBundlerConfig(originalUnpackConfig) {
     await applyPluginsByHook('config', async (impl)=>{
         rest = await impl(rest, {
             ...originalUnpackConfig._context,
-            mergeConfig: utils_mergeConfig
+            mergeConfig: mergeConfig
         });
     });
     let unpackConfig = {
@@ -1081,9 +1132,9 @@ async function getBundlerConfig(originalUnpackConfig) {
         bundlerConfig
     };
     setCurrentUnpackConfig(unpackConfig), await applyPluginsByHook('configResolved', async (impl)=>{
-        await impl(unpackConfig);
+        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.`);
@@ -1200,11 +1251,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',
@@ -1239,12 +1290,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)
                     }
@@ -1342,7 +1393,7 @@ async function getBundlerConfig(originalUnpackConfig) {
                     type: 'css/module'
                 }), getLessLoader = ()=>({
                     loader: getCompiledPkgPath('less-loader'),
-                    options: utils_mergeConfig({
+                    options: mergeConfig({
                         lessOptions: {
                             javascriptEnabled: !0
                         },
@@ -1487,7 +1538,7 @@ async function getBundlerConfig(originalUnpackConfig) {
                     getCssLoader(),
                     {
                         loader: getCompiledPkgPath('less-loader'),
-                        options: utils_mergeConfig({
+                        options: mergeConfig({
                             lessOptions: {
                                 javascriptEnabled: !0
                             },
@@ -1540,7 +1591,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 }) {
@@ -1578,13 +1629,13 @@ async function getBundlerConfig(originalUnpackConfig) {
         unpackConfig
     })), await applyPluginsByHook('bundlerConfig', async (impl)=>{
         config = await impl(config, {
-            ...unpackConfig._context,
+            ...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)=>{
@@ -1595,9 +1646,9 @@ async function unpackBuild(unpackConfig) {
         stats?.hasErrors() && console.log(stats.toString({
             colors: !0,
             preset: 'errors-only'
-        })), isWatch() || compiler.close(()=>{});
+        })), utils_isProd() && compiler.close(()=>{});
     };
-    isWatch() ? compiler.watch({}, handler) : compiler.run(handler);
+    utils_isProd() ? compiler.run(handler) : compiler.watch({}, handler);
 }
 var openBrowser_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 async function openBrowser(url) {
@@ -1705,7 +1756,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.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.2.2`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
         port,
         host: unpackConfig.server.host,
         base: unpackConfig.base
@@ -1719,10 +1770,10 @@ async function unpackDev(unpackConfig) {
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "4.2.0",
+        version: "4.2.2",
         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, VIRTUAL_UNO_CSS_ID, rootDir, unoConfig, tokens, tasks, requestedLayers, layerImportRE, ensureReady, invalidate, flushTasks, getVirtualLayerId, 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, cachedTokensLength, cachedLayersLength, isCompiling, resolveUnocssConfig, flushTasks, getLayersKey, getVirtualModuleContent, hash, restoreSkipCode, applyUnoTransformers, getCustomLayers, optionsFromUnpackConfig, rootPath1, registerCode, namesCode, defaultConfig = {
             root: cwd,
             base: '/',
             sourceMap: 'production' !== mode && 'cheap-module-source-map',
@@ -1866,7 +1917,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)=>{
@@ -2025,8 +2076,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
@@ -2045,10 +2099,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}]` : '[]';
@@ -2062,27 +2116,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
 })()`;
@@ -2095,7 +2158,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 = {
@@ -2373,11 +2436,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;
@@ -2403,7 +2466,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 {
@@ -2445,41 +2508,27 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                         log += colors.blue(displaySize(totalSize)), console.log(log += colors.dim(` │ gzip: ${displaySize(totalCompressedSize)}`));
                     }
                 }),
-                (VIRTUAL_UNO_CSS_ID = 'uno.css', rootDir = process.cwd(), unoConfig = {}, tokens = new Set(), 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\?layer=([^'"]+)\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 = '', cachedTokensLength = 0, cachedLayersLength = 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)) {
-                        let loaded = await loadConfigFile(configFilePath);
-                        if (isFunction(loaded)) {
-                            let result = await loaded({
-                                env: isDev() ? 'development' : 'production',
-                                command: isDev() ? 'dev' : 'build'
-                            });
-                            result && (configFromOption = utils_mergeConfig(configFromOption, result));
-                        } else loaded && (configFromOption = utils_mergeConfig(configFromOption, loaded));
-                    }
-                    resolvedDefaults && (configFromOption = utils_mergeConfig(resolvedDefaults, configFromOption)), unoConfig = configFromOption;
-                    let createGenerator = core.createGenerator;
-                    if (!createGenerator) throw Error('Failed to load "createGenerator" from "@unocss/core".');
-                    uno = await createGenerator(unoConfig), tokens = new Set();
-                }, 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;
                     let pending = tasks.map((t)=>t());
                     tasks = [], await Promise.all(pending);
-                }, getVirtualLayerId = (layer)=>`${VIRTUAL_UNO_CSS_ID}?layer=${encodeURIComponent(layer)}`, getVirtualModuleContent = (layer)=>{
-                    let code, layer1, layersKey = Array.from(requestedLayers).sort().join(','), hash = (code = `${Date.now()}|${layer}|${layersKey}`, createHash('sha256').update(code).digest('hex').slice(0, 8));
-                    return `#--unocss-hash--{content:"${hash}"}${layer1 = encodeURIComponent(layer), `#--unocss--{layer:${layer1};escape-view:\\"\\'\\\`\\\\}`}`;
+                }, getLayersKey = ()=>Array.from(requestedLayers).sort().join(','), getVirtualModuleContent = (layer)=>{
+                    let code, hash = (code = `${tokens.size}|${layer}|${getLayersKey()}`, 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;
                     for(i = 0, l = str.length; i < l; i++)hVal ^= str.charCodeAt(i), hVal += (hVal << 1) + (hVal << 4) + (hVal << 7) + (hVal << 8) + (hVal << 24);
@@ -2489,7 +2538,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     for (let [withHashKey, matched] of map.entries())next = next.replaceAll(withHashKey, matched);
                     return next;
                 }, applyUnoTransformers = async (original, id, enforce = 'default')=>{
-                    if (!uno || original.includes('@unocss-ignore')) return null;
+                    if (original.includes('@unocss-ignore')) return null;
                     let transformers = (uno.config.transformers || []).filter((i)=>(i.enforce || 'default') === enforce);
                     if (!transformers.length) return null;
                     let skipMap = new Map(), code = original, s = new magic_string(((code, map, rules, keyFlag)=>{
@@ -2503,69 +2552,114 @@ 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,
-                    config: (config, { mergeConfig })=>mergeConfig(config, {
-                            performance: {
-                                cache: !1
-                            }
-                        }),
-                    configResolved: async (config)=>{
-                        if (rootDir = config.root || process.cwd(), Array.isArray(config.unocss)) {
-                            let [configOrPathValue, defaultsValue] = config.unocss;
+                    apply: (config)=>!!config.css?.unocss,
+                    configResolved: async (config, { cachePath })=>{
+                        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();
+                        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, clear cache.')), isHashChanged && logger_logger.debug(colors.yellow('[unocss] Config hash changed, clear cache.')), 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) && (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.`)));
+                            }
+                            if (node_fs.existsSync(generatedCachePath)) {
+                                let cached = JSON.parse(node_fs.readFileSync(generatedCachePath, 'utf-8'));
+                                if (cached && cached.meta?.tokensLength === tokens.size && cached.meta?.layersKey === getLayersKey()) {
+                                    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.'));
+                                }
+                            }
+                        })();
                     },
-                    bundlerConfig: (config)=>(config.lazyCompilation = !1, config),
-                    buildStart ({ compiler }) {
-                        compilerRef = compiler;
+                    buildStart () {
+                        isCompiling = !0;
+                    },
+                    buildEnd () {
+                        isCompiling = !1, 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);
                     },
                     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 (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);
+                            }
                             if (JS_REGEX.test(id) && !code.includes('@unocss-include')) return null;
                             let transformedCode = code, preTransformed = await applyUnoTransformers(transformedCode, id, 'pre');
                             null != preTransformed && (transformedCode = preTransformed);
                             let defaultTransformed = await applyUnoTransformers(transformedCode, id, 'default');
                             null != defaultTransformed && (transformedCode = defaultTransformed);
                             let postTransformed = await applyUnoTransformers(transformedCode, id, 'post');
-                            return null != postTransformed && (transformedCode = postTransformed), transformedCode.includes('uno.css?layer=') && (transformedCode = transformedCode.replace(layerImportRE, (_, quote, layer)=>{
-                                let decodedLayer = ((layer)=>{
-                                    try {
-                                        return decodeURIComponent(layer);
-                                    } catch  {
-                                        return layer;
-                                    }
-                                })(layer);
-                                return requestedLayers.add(decodedLayer), `${quote}${getVirtualLayerId(decodedLayer)}${quote}`;
-                            })), task = async ()=>{
-                                await uno.applyExtractors(code.replace(SKIP_COMMENT_RE, ''), id, tokens);
+                            return null != postTransformed && (transformedCode = postTransformed), task = async ()=>{
+                                await uno.applyExtractors(transformedCode.replace(SKIP_COMMENT_RE, ''), id, tokens);
                             }, tasks.push(task), transformedCode === code ? null : transformedCode;
                         }
                     },
                     processAssets: {
                         stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
                         handler: async ({ compilation, sources })=>{
-                            if (await flushTasks(), !uno) return;
-                            let resolvedLayers = getResolvedLayers(), result = await uno.generate(tokens, {
-                                minify: !0
-                            });
+                            await flushTasks();
+                            let layersKey = getLayersKey();
+                            if (!generated || generated.meta.tokensLength !== tokens.size || generated.meta.layersKey !== layersKey) {
+                                let result = await uno.generate(tokens, {
+                                    minify: !0
+                                }), customLayers = getCustomLayers();
+                                generated = {
+                                    meta: {
+                                        tokensLength: tokens.size,
+                                        layersKey
+                                    },
+                                    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));
                             }
@@ -2573,7 +2667,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     },
                     virtualModules: ()=>({
                             [VIRTUAL_UNO_CSS_ID]: getVirtualModuleContent(LAYER_MARK_ALL),
-                            ...getResolvedLayers().reduce((acc, layer)=>(acc[getVirtualLayerId(layer)] = getVirtualModuleContent(layer), acc), {})
+                            ...getCustomLayers().reduce((acc, layer)=>(acc[`uno:${layer}.css`] = getVirtualModuleContent(layer), acc), {})
                         })
                 }),
                 (rootPath1 = '', registerCode = '', namesCode = '', {
@@ -2609,7 +2703,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
             ]
         };
         return {
-            ...utils_mergeConfig(defaultConfig, userConfig),
+            ...mergeConfig(defaultConfig, userConfig),
             _context
         };
     };
@@ -2618,7 +2712,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.0`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v4.2.2`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
             setUnpackStartTime(performance.now());
@@ -2767,7 +2861,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.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.2.2"), 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, 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, isWatch, isWin, launchEditor, loadConfig, 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 };