@unpackjs/core 4.0.0 → 4.2.0

package/dist/index.js

@@ -6,17 +6,19 @@ import node_path, { dirname as __rspack_dirname, join, sep } from "node:path";
 import * as __rspack_external__compiled_launch_editor_index_js_29002383 from "../compiled/launch-editor/index.js";
 import * as __rspack_external__compiled_webpack_merge_index_js_efd91626 from "../compiled/webpack-merge/index.js";
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { rspack } from "@rspack/core";
-import node_fs from "node:fs";
+import { Compilation, rspack } from "@rspack/core";
 import cac from "cac";
+import node_fs from "node:fs";
 import node_readline from "node:readline";
 import node_os, { platform } from "node:os";
 import portfinder from "portfinder";
+import { glob as external_tinyglobby_glob, globSync } from "tinyglobby";
 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 { glob, globSync } from "tinyglobby";
+import { createHash } from "node:crypto";
+import magic_string from "magic-string";
 import { expand } from "dotenv-expand";
 import node_assert from "node:assert";
 import { RspackDevServer } from "@rspack/dev-server";
@@ -120,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: mergeConfig } = __webpack_require__("compiled/webpack-merge"), { default: launchEditor } = __webpack_require__("compiled/launch-editor"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
+let { merge: utils_mergeConfig } = __webpack_require__("compiled/webpack-merge"), { default: launchEditor } = __webpack_require__("compiled/launch-editor"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
     process.env.NODE_ENV = env;
 }, setDevServer = (isDevServer)=>{
     process.env.DEV_SERVER = isDevServer ? 'true' : 'false';
@@ -476,31 +478,107 @@ let removeDir = (dir)=>{
     currentUnpackConfig = config;
 }, unpackStartTime = 0, getUnpackStartTime = ()=>unpackStartTime, setUnpackStartTime = (time)=>{
     unpackStartTime = time;
-}, STYLE_IMPORT_RE = /import\s+([\s\S]+?)\s+from\s+(['"])(.*?\.(?:css|less|scss|sass))\2/g, TYPE_IMPORT_CLAUSE_RE = /^\s*type\b/, STYLE_EXT_HINTS = [
+}, STYLE_IMPORT_RE = /import\s+((?:(?!\nimport\s)[\s\S])*?)\s+from\s+(['"])([^'"]+?\.(?:css|less|scss|sass)(?:\?[^'"]+)?(?:#[^'"]+)?)\2/g, TYPE_IMPORT_CLAUSE_RE = /^\s*type\b/, STYLE_EXT_HINTS = [
     '.css',
     '.less',
     '.scss',
     '.sass'
-], BROWSER_LOGS_ENDPOINT = '/__browser_logs__', browserLogs_SCRIPT_REGEX = /\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|vue|svelte)$/, gzip = promisify(node_zlib.gzip), numberFormatter = new Intl.NumberFormat('en', {
+], BROWSER_LOGS_ENDPOINT = '/__browser_logs__', SOURCE_REGEX = /\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|vue|svelte)$/, gzip = promisify(node_zlib.gzip), numberFormatter = new Intl.NumberFormat('en', {
     maximumFractionDigits: 2,
     minimumFractionDigits: 2
 }), displaySize = (bytes)=>`${numberFormatter.format(bytes / 1000)} kB`;
 async function getCompressedSize(content) {
     return (await gzip(content)).length;
 }
-let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|md)$/i, SPECIAL_NO_ENTRY_DEPS = [
+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)=>{
+    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}__`)),
+                expansions
+            }), source = replaced.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            return 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(/\\\(([^)]+)\\\)\\\?/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 = [
     '@iconify-icons/material-symbols'
+], FRAMEWORKS = [
+    'react',
+    'react-dom',
+    'react-router-dom',
+    'vue',
+    'vue-router'
 ], getExternalLibraryName = (pkgName)=>{
     let externalAlias = {
-        react: 'React',
         'react-dom': 'ReactDOM',
         'react-router-dom': 'ReactRouterDOM'
     };
     return externalAlias[pkgName] ? externalAlias[pkgName] : pkgName.replace(/^@/, '').split(/[/\-.]/).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
-}, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+}, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, normalizeSvg = (content)=>content.replace(/<\?xml[\s\S]*?\?>/gi, '').replace(/<!DOCTYPE[\s\S]*?>/gi, '').replace(/<!--[\s\S]*?-->/g, '').trim(), extractSvgContent = (content)=>{
+    let match = content.match(/<svg\b([^>]*)>/i), viewBoxMatch = match?.[1]?.match(/viewBox\s*=\s*["']([^"']+)["']/i);
+    return {
+        inner: content.replace(/^[\s\S]*?<svg\b[^>]*>/i, '').replace(/<\/svg>[\s\S]*$/i, '').trim(),
+        viewBox: viewBoxMatch?.[1]
+    };
+}, readSvgFiles = (dir, collected = [])=>{
+    if (!node_fs.existsSync(dir)) return collected;
+    for (let entry of node_fs.readdirSync(dir, {
+        withFileTypes: !0
+    })){
+        let fullPath = node_path.join(dir, entry.name);
+        entry.isDirectory() ? readSvgFiles(fullPath, collected) : entry.isFile() && entry.name.toLowerCase().endsWith('.svg') && collected.push(fullPath);
+    }
+    return collected;
+}, toSymbolId = (filePath, iconDir, symbolId)=>{
+    let relative = node_path.relative(iconDir, filePath), parsed = node_path.parse(relative), dir = parsed.dir.split(node_path.sep).filter(Boolean).join('-'), name = parsed.name;
+    if ('function' == typeof symbolId) return symbolId(name, filePath);
+    let id = (symbolId || 'icon-[dir]-[name]').replace(/\[name\]/g, name).replace(/\[dir\]/g, dir);
+    return id.replace(/--+/g, '-').replace(/^-+|-+$/g, '');
+}, UNOCSS_CONFIG_FILES = [
+    'unocss.config.mjs',
+    'unocss.config.ts',
+    'unocss.config.js',
+    'unocss.config.mts',
+    'uno.config.mjs',
+    '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)=>{
+    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);
+}, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function getNormalizedPluginsByHook(hook) {
     let pluginMap = new Map();
-    return getCurrentUnpackConfig().plugins?.forEach((plugin)=>{
+    (getCurrentUnpackConfig().plugins?.flat(1 / 0) || []).forEach((plugin)=>{
         plugin && ((plugin, hook)=>{
             if (!plugin[hook]) return !1;
             let apply = plugin.apply;
@@ -511,12 +589,60 @@ function getNormalizedPluginsByHook(hook) {
             };
             return 'string' == typeof apply ? apply === env.command : !!apply(getCurrentUnpackConfig(), env);
         })(plugin, hook) && pluginMap.set(plugin.name, plugin);
-    }), Array.from(pluginMap.values());
+    });
+    let normalizedPlugins = Array.from(pluginMap.values()), enforceOrder = (plugin)=>'pre' === plugin.enforce ? 0 : 'post' === plugin.enforce ? 2 : 1;
+    return normalizedPlugins.map((plugin, index)=>({
+            plugin,
+            index
+        })).sort((a, b)=>{
+        let diff = enforceOrder(a.plugin) - enforceOrder(b.plugin);
+        return 0 !== diff ? diff : a.index - b.index;
+    }).map((item)=>item.plugin);
 }
+let createPluginHookTimer = (plugin, hook)=>{
+    let startTime = 0;
+    return {
+        start: ()=>{
+            startTime = performance.now();
+        },
+        end: ()=>{
+            let duration = performance.now() - startTime;
+            logger_logger.debug(`${colors.magenta('[plugin]')} ${colors.cyan(plugin.name)} ${colors.blue(hook)} ${colors.dim('in')} ${colors.yellow(`${duration.toFixed(2)}ms`)}`);
+        }
+    };
+}, TRANSFORM_TIMING_STORE = Symbol.for('unpack:transformTimingMap'), globalScope = globalThis, transformTimingMap = globalScope[TRANSFORM_TIMING_STORE] ?? new WeakMap();
 async function applyPluginsByHook(hook, runner) {
+    let shouldMeasure = 'processAssets' !== hook && 'transform' !== hook;
+    for (let plugin of getNormalizedPluginsByHook(hook)){
+        let impl = plugin[hook];
+        if (!shouldMeasure) {
+            await runner(impl, plugin);
+            continue;
+        }
+        let timer = createPluginHookTimer(plugin, hook);
+        timer.start();
+        try {
+            await runner(impl, plugin);
+        } finally{
+            timer.end();
+        }
+    }
+}
+function applyPluginsByHookSync(hook, runner) {
+    let shouldMeasure = 'processAssets' !== hook && 'transform' !== hook;
     for (let plugin of getNormalizedPluginsByHook(hook)){
         let impl = plugin[hook];
-        await runner(impl);
+        if (!shouldMeasure) {
+            runner(impl, plugin);
+            continue;
+        }
+        let timer = createPluginHookTimer(plugin, hook);
+        timer.start();
+        try {
+            runner(impl, plugin);
+        } finally{
+            timer.end();
+        }
     }
 }
 async function applyBuildAnalyzeConfig({ config, unpackConfig }) {
@@ -561,7 +687,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 mergeConfig(config, {
+    return utils_mergeConfig(config, {
         cache: !0,
         experiments: {
             cache: {
@@ -575,6 +701,7 @@ async function applyCacheConfig({ config, unpackConfig, envFilePaths }) {
         }
     });
 }
+globalScope[TRANSFORM_TIMING_STORE] = transformTimingMap;
 let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, SPLIT_STRATEGY_DISPATCHER = {
     'split-by-module': function(ctx) {
         let { forceSplittingGroups, defaultConfig } = ctx;
@@ -661,7 +788,7 @@ let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\
 };
 async function getEntry(root, customEntry) {
     let entry;
-    if (entry = customEntry ? node_path.resolve(root, customEntry) : (await glob('(index|Index).{js,ts,jsx,tsx}', {
+    if (entry = customEntry ? node_path.resolve(root, customEntry) : (await external_tinyglobby_glob('(index|Index).{js,ts,jsx,tsx}', {
         cwd: node_path.join(root, 'src'),
         absolute: !0
     }))[0], !node_fs.existsSync(entry)) throw Error('could not find entry file');
@@ -691,6 +818,7 @@ async function applyHtmlConfig({ config, unpackConfig }) {
         ]
     })), config;
 }
+var nativeCss_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 let { RawSource: RawSource, SourceMapSource: SourceMapSource } = rspack.sources, isJsFile = /\.[cm]?js(\?.*)?$/i, jsMinify_PLUGIN_NAME = 'JsMinifyPlugin';
 class JsMinifyPlugin {
     minifyOptions;
@@ -702,7 +830,7 @@ class JsMinifyPlugin {
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "4.0.0",
+            version: "4.2.0",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -805,15 +933,15 @@ async function compileDone(compiler, stats) {
         if (!fileInfo) return;
         if (fileInfo === lastFileInfo ? sameCount++ : (lastFileInfo = fileInfo, sameCount = 1), isDebug()) {
             var modules;
-            let nodeModulesStats, nodeModulesPath;
-            Object.entries((modules = stats.compilation.modules, nodeModulesStats = {}, nodeModulesPath = node_path.resolve(root, 'node_modules'), modules.forEach((module)=>{
+            let nodeModulesStats, nodeModulesPath, sortedStats;
+            (sortedStats = Object.entries((modules = stats.compilation.modules, nodeModulesStats = {}, nodeModulesPath = node_path.resolve(root, 'node_modules'), modules.forEach((module)=>{
                 let { resource } = module;
                 if (resource?.includes(nodeModulesPath)) {
                     let packageName, pathParts = node_path.relative(nodeModulesPath, resource).split(sep);
                     (packageName = '.pnpm' === pathParts[0] && pathParts.length >= 4 ? pathParts[3].startsWith('@') ? `${pathParts[3]}/${pathParts[4]}` : pathParts[3] : pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0]) && (nodeModulesStats[packageName] = (nodeModulesStats[packageName] || 0) + 1);
                 }
-            }), nodeModulesStats)).sort((a, b)=>a[1] - b[1]).forEach(([packageName, count])=>{
-                count > 10 && logger_logger.debug(`${colors.cyan(packageName)}: ${colors.yellow(count)} modules`);
+            }), nodeModulesStats)).sort((a, b)=>a[1] - b[1])).forEach(([packageName, count], i)=>{
+                i >= sortedStats.length - 10 && logger_logger.debug(`[dependency] ${colors.cyan(packageName)}: ${colors.yellow(count)} modules`);
             });
         }
         isDebug() || logger_logger.clear(), console.log(colors.dim(getTime()), colors.cyan(`[${getCurrentUnpackConfig()._context.callerName}]`), colors.brand(utils_isDevServer() ? 'hmr update' : 'build'), `${colors.dim(fileInfo)}${sameCount > 1 ? ` ${colors.yellow(`(x${sameCount})`)}` : ''}`, isDebug() ? colors.dim(`| ${prettyTime(getCompileTime(stats))} (${stats.compilation.modules.size} modules)`) : '');
@@ -847,7 +975,8 @@ let registerHooks_PLUGIN_NAME = 'RegisterHooksPlugin';
 class RegisterHooksPlugin {
     isFirstCompile = !0;
     apply(compiler) {
-        compiler.hooks.beforeCompile.tapPromise(registerHooks_PLUGIN_NAME, async ()=>{
+        let virtualModulesPlugin = new rspack.experiments.VirtualModulesPlugin();
+        virtualModulesPlugin.apply(compiler), compiler.hooks.beforeCompile.tapPromise(registerHooks_PLUGIN_NAME, async ()=>{
             await applyPluginsByHook('buildStart', async (impl)=>{
                 await impl({
                     compiler,
@@ -856,18 +985,54 @@ class RegisterHooksPlugin {
                 });
             });
         }), compiler.hooks.done.tapPromise(registerHooks_PLUGIN_NAME, async (stats)=>{
-            await applyPluginsByHook('buildEnd', async (impl)=>{
-                await impl({
-                    compiler,
-                    isFirstCompile: this.isFirstCompile,
-                    isWatch: isWatch(),
-                    stats
+            try {
+                await applyPluginsByHook('buildEnd', async (impl)=>{
+                    await impl({
+                        compiler,
+                        isFirstCompile: this.isFirstCompile,
+                        isWatch: isWatch(),
+                        stats
+                    });
                 });
-            }), this.isFirstCompile = !1;
+            } 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)=>{
+            applyPluginsByHookSync('virtualModules', (impl)=>{
+                Object.entries(impl()).forEach(([path, content])=>{
+                    virtualModulesPlugin.writeModule(path, content);
+                });
+            }), applyPluginsByHook('processAssets', (impl, plugin)=>{
+                let { stage, handler } = impl;
+                compilation.hooks.processAssets.tapPromise({
+                    name: registerHooks_PLUGIN_NAME,
+                    stage
+                }, async (assets)=>{
+                    let timer = createPluginHookTimer(plugin, 'processAssets');
+                    timer.start();
+                    try {
+                        await handler({
+                            assets,
+                            compilation,
+                            sources: rspack.sources,
+                            compiler
+                        });
+                    } finally{
+                        timer.end();
+                    }
+                });
+            });
         });
     }
 }
@@ -907,7 +1072,7 @@ async function getBundlerConfig(originalUnpackConfig) {
     await applyPluginsByHook('config', async (impl)=>{
         rest = await impl(rest, {
             ...originalUnpackConfig._context,
-            mergeConfig: mergeConfig
+            mergeConfig: utils_mergeConfig
         });
     });
     let unpackConfig = {
@@ -928,14 +1093,14 @@ async function getBundlerConfig(originalUnpackConfig) {
             `.env.${mode}`,
             `.env.${mode}.local`
         ].map((filename)=>join(cwd, filename)).filter(isFileSync), parsed = {};
-        for (let envPath of filePaths)Object.assign(parsed, function(src) {
+        for (let envPath of filePaths)logger_logger.debug('loading env file:', colors.dim(envPath)), Object.assign(parsed, function(src) {
             let match, obj = {}, lines = src.toString();
             for(lines = lines.replace(/\r\n?/gm, '\n'); null != (match = DOTENV_LINE.exec(lines));){
                 let key = match[1], value = match[2] || '', maybeQuote = (value = value.trim())[0];
                 value = value.replace(/^(['"`])([\s\S]*)\1$/gm, '$2'), '"' === maybeQuote && (value = (value = value.replace(/\\n/g, '\n')).replace(/\\r/g, '\r')), obj[key] = value;
             }
             return obj;
-        }(node_fs.readFileSync(envPath))), logger_logger.debug('loaded env file:', envPath);
+        }(node_fs.readFileSync(envPath)));
         parsed.NODE_ENV && (processEnv.NODE_ENV = parsed.NODE_ENV), expand({
             parsed,
             processEnv
@@ -1074,12 +1239,12 @@ async function getBundlerConfig(originalUnpackConfig) {
             moduleIds: isDev() ? 'named' : 'deterministic',
             minimize: !!unpackConfig.build?.minify && utils_isProd(),
             minimizer: [
-                new JsMinifyPlugin(mergeConfig({
+                new JsMinifyPlugin(utils_mergeConfig({
                     compress: {
                         target: unpackConfig.build.target
                     }
                 }, minifyOptions.oxc || {})),
-                new rspack.LightningCssMinimizerRspackPlugin(mergeConfig({
+                new rspack.LightningCssMinimizerRspackPlugin(utils_mergeConfig({
                     minimizerOptions: {
                         targets: esVersionToBrowserslist(unpackConfig.build.target)
                     }
@@ -1093,9 +1258,9 @@ async function getBundlerConfig(originalUnpackConfig) {
             hints: !1
         }
     };
-    for (let plugin of getNormalizedPluginsByHook('transform')){
-        let { filter, handler } = plugin.transform;
-        config.module.rules.push({
+    return applyPluginsByHookSync('transform', (impl, plugin)=>{
+        let { filter, handler } = impl;
+        config.module.rules.unshift({
             exclude: NODE_MODULES_REGEX,
             ...filter,
             enforce: 'pre',
@@ -1103,13 +1268,13 @@ async function getBundlerConfig(originalUnpackConfig) {
                 {
                     loader: node_path.resolve(bundler_config_dirname, './transformLoader.js'),
                     options: {
-                        handler
+                        handler,
+                        pluginName: plugin.name
                     }
                 }
             ]
         });
-    }
-    return config = (({ config, unpackConfig })=>{
+    }), config = (({ config, unpackConfig })=>{
         let { chunkSplit } = unpackConfig.performance || {};
         if (chunkSplit?.strategy) {
             let forceSplittingGroups = {};
@@ -1139,7 +1304,7 @@ async function getBundlerConfig(originalUnpackConfig) {
         }
         return config;
     })({
-        config: config = unpackConfig.experiments?.css ? function({ config, unpackConfig }) {
+        config: config = unpackConfig.css?.native ? function({ config, unpackConfig }) {
             config.output.cssFilename = getOutputFilename({
                 type: 'css',
                 hash: unpackConfig.build?.filenameHash
@@ -1168,28 +1333,33 @@ async function getBundlerConfig(originalUnpackConfig) {
             });
             let withCssModules = ({ use })=>({
                     resourceQuery: /[?&]module(?:[=&]|$)/,
-                    use,
+                    use: [
+                        isDev() && {
+                            loader: node_path.resolve(nativeCss_dirname, './typedCssModulesLoader.js')
+                        },
+                        ...use
+                    ].filter(Boolean),
                     type: 'css/module'
                 }), getLessLoader = ()=>({
                     loader: getCompiledPkgPath('less-loader'),
-                    options: {
-                        lessOptions: mergeConfig({
+                    options: utils_mergeConfig({
+                        lessOptions: {
                             javascriptEnabled: !0
-                        }, unpackConfig.css?.less || {}),
+                        },
                         implementation: getUserDepPath(unpackConfig.root, 'less'),
                         sourceMap
-                    }
+                    }, unpackConfig.css?.lessLoader || {})
                 }), getCssLoader = ()=>unpackConfig.css?.transformer === 'lightningcss' ? {
                     loader: 'builtin:lightningcss-loader',
                     options: {
                         targets: esVersionToBrowserslist(unpackConfig.build.target),
-                        ...unpackConfig.css?.lightningcss
+                        ...unpackConfig.css?.lightningcssLoader
                     }
                 } : {
                     loader: getCompiledPkgPath('postcss-loader'),
                     options: {
-                        postcssOptions: unpackConfig.css?.postcss,
-                        sourceMap
+                        sourceMap,
+                        ...unpackConfig.css?.postcssLoader
                     }
                 }, getSassLoader = ()=>({
                     loader: getCompiledPkgPath('sass-loader'),
@@ -1199,8 +1369,8 @@ async function getBundlerConfig(originalUnpackConfig) {
                             'sass-embedded',
                             'sass'
                         ]),
-                        sassOptions: unpackConfig.css?.sass,
-                        sourceMap
+                        sourceMap,
+                        ...unpackConfig.css?.sassLoader
                     }
                 });
             return config.module.rules.push({
@@ -1299,13 +1469,13 @@ async function getBundlerConfig(originalUnpackConfig) {
                     loader: 'builtin:lightningcss-loader',
                     options: {
                         targets: esVersionToBrowserslist(unpackConfig.build.target),
-                        ...unpackConfig.css?.lightningcss
+                        ...unpackConfig.css?.lightningcssLoader
                     }
                 } : {
                     loader: getCompiledPkgPath('postcss-loader'),
                     options: {
-                        postcssOptions: unpackConfig.css?.postcss,
-                        sourceMap
+                        sourceMap,
+                        ...unpackConfig.css?.postcssLoader
                     }
                 };
             return config.module.rules.push({
@@ -1317,13 +1487,13 @@ async function getBundlerConfig(originalUnpackConfig) {
                     getCssLoader(),
                     {
                         loader: getCompiledPkgPath('less-loader'),
-                        options: {
-                            lessOptions: mergeConfig({
+                        options: utils_mergeConfig({
+                            lessOptions: {
                                 javascriptEnabled: !0
-                            }, unpackConfig.css?.less || {}),
+                            },
                             implementation: getUserDepPath(unpackConfig.root, 'less'),
                             sourceMap
-                        }
+                        }, unpackConfig.css?.lessLoader || {})
                     }
                 ]
             }), config.module.rules.push({
@@ -1349,8 +1519,8 @@ async function getBundlerConfig(originalUnpackConfig) {
                                 'sass-embedded',
                                 'sass'
                             ]),
-                            sassOptions: unpackConfig.css?.sass,
-                            sourceMap
+                            sourceMap,
+                            ...unpackConfig.css?.sassLoader
                         }
                     }
                 ]
@@ -1410,11 +1580,11 @@ async function getBundlerConfig(originalUnpackConfig) {
         config = await impl(config, {
             ...unpackConfig._context,
             unpackConfig,
-            mergeConfig: mergeConfig
+            mergeConfig: utils_mergeConfig
         });
     }), unpackConfig.bundlerConfig && (config = isFunction(unpackConfig.bundlerConfig) ? await unpackConfig.bundlerConfig(config, {
-        mergeConfig: mergeConfig
-    }) : mergeConfig(config, unpackConfig.bundlerConfig)), config;
+        mergeConfig: utils_mergeConfig
+    }) : utils_mergeConfig(config, unpackConfig.bundlerConfig)), config;
 }
 async function unpackBuild(unpackConfig) {
     let compiler = rspack(await getBundlerConfig(unpackConfig)), handler = (err, stats)=>{
@@ -1535,7 +1705,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.0.0${unpackConfig.performance?.cache ? ' ϟ' : ''}`)}  ${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.0`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
         port,
         host: unpackConfig.server.host,
         base: unpackConfig.base
@@ -1549,162 +1719,160 @@ async function unpackDev(unpackConfig) {
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "4.0.0",
+        version: "4.2.0",
         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;
-        return {
-            ...mergeConfig({
-                root: cwd,
-                base: '/',
-                sourceMap: 'production' !== mode && 'cheap-module-source-map',
-                build: {
-                    outDir: 'dist',
-                    minify: !0,
-                    filenameHash: !0,
-                    target: 'es2023'
-                },
-                server: {
-                    port: 3000,
-                    host: !1
-                },
-                html: {
-                    mountId: 'root'
-                },
-                css: {
-                    transformer: 'postcss',
-                    sourceMap: !1
+        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 = {
+            root: cwd,
+            base: '/',
+            sourceMap: 'production' !== mode && 'cheap-module-source-map',
+            build: {
+                outDir: 'dist',
+                minify: !0,
+                filenameHash: !0,
+                target: 'es2023'
+            },
+            server: {
+                port: 3000,
+                host: !1
+            },
+            html: {
+                mountId: 'root'
+            },
+            css: {
+                transformer: 'postcss',
+                sourceMap: !1
+            },
+            performance: {
+                chunkSplit: {
+                    strategy: 'single-vendor'
                 },
-                performance: {
-                    chunkSplit: {
-                        strategy: 'single-vendor'
-                    },
-                    printFileSize: !0,
-                    cache: !0
+                printFileSize: !0
+            },
+            typeCheck: !0,
+            envPrefix: [
+                'PUBLIC_',
+                'VITE_'
+            ],
+            plugins: [
+                {
+                    name: 'unpack:auto-css-modules',
+                    transform: {
+                        filter: {
+                            test: /\.(?:[jt]sx|vue)$/
+                        },
+                        handler: (code)=>STYLE_EXT_HINTS.some((ext)=>code.includes(ext)) ? code.replace(STYLE_IMPORT_RE, (full, importClause, quote, spec)=>TYPE_IMPORT_CLAUSE_RE.test(importClause) || spec.includes('?') || spec.includes('#') ? full : `import ${importClause} from ${quote}${spec}?module${quote}`) : null
+                    }
                 },
-                typeCheck: !0,
-                envPrefix: [
-                    'PUBLIC_'
-                ],
-                plugins: [
-                    {
-                        name: 'unpack:auto-css-modules',
-                        transform: {
-                            filter: {
-                                test: JSX_REGEX
-                            },
-                            handler: (code)=>STYLE_EXT_HINTS.some((ext)=>code.includes(ext)) ? code.replace(STYLE_IMPORT_RE, (full, importClause, quote, spec)=>TYPE_IMPORT_CLAUSE_RE.test(importClause) || spec.includes('?') || spec.includes('#') ? full : `import ${importClause} from ${quote}${spec}?module${quote}`) : null
+                (rootPath = '', outputPath = '', basePath = '/', cachedTraceMap = new Map(), fs = null, isValidMethodName = (methodName)=>'<unknown>' !== methodName && !/[\\/]/.test(methodName), parseFrame = async (frame)=>{
+                    let { file, column, lineNumber } = frame;
+                    if (!file || null == lineNumber || null == column) return;
+                    let localPath = file;
+                    try {
+                        let pathname = new URL(file).pathname;
+                        if ('/' !== basePath) {
+                            let normalizedBase = basePath;
+                            pathname.startsWith(normalizedBase) && (pathname = pathname.slice(normalizedBase.length));
                         }
-                    },
-                    (rootPath = '', outputPath = '', basePath = '/', cachedTraceMap = new Map(), fs = null, isValidMethodName = (methodName)=>'<unknown>' !== methodName && !/[\\/]/.test(methodName), parseFrame = async (frame)=>{
-                        let { file, column, lineNumber } = frame;
-                        if (!file || null == lineNumber || null == column) return;
-                        let localPath = file;
-                        try {
-                            let pathname = new URL(file).pathname;
-                            if ('/' !== basePath) {
-                                let normalizedBase = basePath;
-                                pathname.startsWith(normalizedBase) && (pathname = pathname.slice(normalizedBase.length));
-                            }
-                            localPath = node_path.join(outputPath, pathname);
-                        } catch  {
-                            node_path.isAbsolute(file) || (localPath = node_path.join(outputPath, file));
+                        localPath = node_path.join(outputPath, pathname);
+                    } catch  {
+                        node_path.isAbsolute(file) || (localPath = node_path.join(outputPath, file));
+                    }
+                    let sourceMapPath = `${localPath}.map`;
+                    try {
+                        if (!fs.existsSync(sourceMapPath)) return;
+                        let tracer = cachedTraceMap.get(sourceMapPath);
+                        if (!tracer) {
+                            let readFile = promisify(fs.readFile), sourceMapContent = await readFile(sourceMapPath, 'utf-8');
+                            if (!sourceMapContent) return;
+                            tracer = new TraceMap(sourceMapContent), cachedTraceMap.set(sourceMapPath, tracer);
                         }
-                        let sourceMapPath = `${localPath}.map`;
-                        try {
-                            if (!fs.existsSync(sourceMapPath)) return;
-                            let tracer = cachedTraceMap.get(sourceMapPath);
-                            if (!tracer) {
-                                let readFile = promisify(fs.readFile), sourceMapContent = await readFile(sourceMapPath, 'utf-8');
-                                if (!sourceMapContent) return;
-                                tracer = new TraceMap(sourceMapContent), cachedTraceMap.set(sourceMapPath, tracer);
-                            }
-                            let originalPosition = originalPositionFor(tracer, {
-                                line: lineNumber,
-                                column: column
-                            });
-                            return {
-                                sourceMapPath,
-                                originalPosition
-                            };
-                        } catch  {
-                            return;
+                        let originalPosition = originalPositionFor(tracer, {
+                            line: lineNumber,
+                            column: column
+                        });
+                        return {
+                            sourceMapPath,
+                            originalPosition
+                        };
+                    } catch  {
+                        return;
+                    }
+                }, formatOriginalLocation = (originalMapping)=>{
+                    let { source, line, column } = originalMapping;
+                    if (!source) return;
+                    let relativeSource = source;
+                    if (source.includes('webpack://')) {
+                        let segments = (relativeSource = source.replace(/webpack:\/\/\/?/, '')).split(/[\\/]/);
+                        [
+                            'src',
+                            'node_modules'
+                        ].includes(segments[1]) && (segments.shift(), relativeSource = segments.join('/'));
+                    }
+                    let result = relativeSource;
+                    return null !== line && (result += null === column ? `:${line}` : `:${line}:${column}`), result;
+                }, formatFullStack = async (stackFrames)=>{
+                    let allLines = [], srcLines = [];
+                    for (let frame of stackFrames){
+                        let parsedFrame = await parseFrame(frame), { methodName } = frame, parts = [];
+                        methodName && isValidMethodName(methodName) && parts.push(methodName);
+                        let parsed = !1;
+                        if (parsedFrame) {
+                            let { originalPosition } = parsedFrame, originalLocation = formatOriginalLocation(originalPosition);
+                            originalLocation && (parts.push(originalLocation), parsed = !0);
                         }
-                    }, formatOriginalLocation = (originalMapping)=>{
-                        let { source, line, column } = originalMapping;
-                        if (!source) return;
-                        let relativeSource = source;
-                        if (source.includes('webpack://')) {
-                            let segments = (relativeSource = source.replace(/webpack:\/\/\/?/, '')).split(/[\\/]/);
-                            [
-                                'src',
-                                'node_modules'
-                            ].includes(segments[1]) && (segments.shift(), relativeSource = segments.join('/'));
+                        if (!parsed && frame.file) try {
+                            let url = new URL(frame.file);
+                            parts.push(`${url.pathname}:${frame.lineNumber}:${frame.column}`);
+                        } catch  {
+                            parts.push(`${frame.file}:${frame.lineNumber}:${frame.column}`);
                         }
-                        let result = relativeSource;
-                        return null !== line && (result += null === column ? `:${line}` : `:${line}:${column}`), result;
-                    }, formatFullStack = async (stackFrames)=>{
-                        let allLines = [], srcLines = [];
-                        for (let frame of stackFrames){
-                            let parsedFrame = await parseFrame(frame), { methodName } = frame, parts = [];
-                            methodName && isValidMethodName(methodName) && parts.push(methodName);
-                            let parsed = !1;
-                            if (parsedFrame) {
-                                let { originalPosition } = parsedFrame, originalLocation = formatOriginalLocation(originalPosition);
-                                originalLocation && (parts.push(originalLocation), parsed = !0);
-                            }
-                            if (!parsed && frame.file) try {
-                                let url = new URL(frame.file);
-                                parts.push(`${url.pathname}:${frame.lineNumber}:${frame.column}`);
-                            } catch  {
-                                parts.push(`${frame.file}:${frame.lineNumber}:${frame.column}`);
-                            }
-                            if (parts.length > 0) {
-                                let loc = parts.length > 1 ? `(${parts[1]})` : parts[0].includes(':') ? `(${parts[0]})` : parts[0], func = parts.length > 1 ? parts[0] : parts[0].includes(':') ? '' : parts[0], line = func ? `\n    at ${func} ${loc}` : `\n    at ${loc}`;
-                                allLines.push(line);
-                                let locationText = loc.startsWith('(') && loc.endsWith(')') ? loc.slice(1, -1) : loc;
-                                /(^|[\\/])src[\\/]/.test(locationText) && srcLines.push(line);
-                            }
+                        if (parts.length > 0) {
+                            let loc = parts.length > 1 ? `(${parts[1]})` : parts[0].includes(':') ? `(${parts[0]})` : parts[0], func = parts.length > 1 ? parts[0] : parts[0].includes(':') ? '' : parts[0], line = func ? `\n    at ${func} ${loc}` : `\n    at ${loc}`;
+                            allLines.push(line);
+                            let locationText = loc.startsWith('(') && loc.endsWith(')') ? loc.slice(1, -1) : loc;
+                            /(^|[\\/])src[\\/]/.test(locationText) && srcLines.push(line);
                         }
-                        return srcLines.length > 0 ? srcLines[0] : allLines.join('');
-                    }, resolveErrorLocationAndStack = async (item)=>{
-                        let locationFromMsg = item.message ? ((message)=>{
-                            let match = message.match(/((?:[A-Za-z]:)?\/[^\s:]+):(\d+):(\d+)/);
-                            if (!match) return;
-                            let [, absPath, line, column] = match, source = absPath;
-                            return absPath.startsWith(rootPath + node_path.sep) && (source = node_path.relative(rootPath, absPath)), `${source}:${Number(line)}:${Number(column)}`;
-                        })(item.message) : null;
-                        if (locationFromMsg) return {
-                            locationSuffix: colors.dim(`(${locationFromMsg})`),
-                            stackString: ''
-                        };
-                        if (!item.stack) return {
-                            locationSuffix: '',
+                    }
+                    return srcLines.length > 0 ? srcLines[0] : allLines.join('');
+                }, resolveErrorLocationAndStack = async (item)=>{
+                    let locationFromMsg = item.message ? ((message)=>{
+                        let match = message.match(/((?:[A-Za-z]:)?\/[^\s:]+):(\d+):(\d+)/);
+                        if (!match) return;
+                        let [, absPath, line, column] = match, source = absPath;
+                        return absPath.startsWith(rootPath + node_path.sep) && (source = node_path.relative(rootPath, absPath)), `${source}:${Number(line)}:${Number(column)}`;
+                    })(item.message) : null;
+                    if (locationFromMsg) return {
+                        locationSuffix: colors.dim(`(${locationFromMsg})`),
+                        stackString: ''
+                    };
+                    if (!item.stack) return {
+                        locationSuffix: '',
+                        stackString: ''
+                    };
+                    let parsedFrames = parse(item.stack), userFrame = parsedFrames.find((frame)=>frame.file && null !== frame.lineNumber && null !== frame.column && SOURCE_REGEX.test(frame.file));
+                    if (userFrame) {
+                        let parsedUserFrame = await parseFrame(userFrame), loc = parsedUserFrame ? formatOriginalLocation(parsedUserFrame.originalPosition) : null;
+                        if (loc) return {
+                            locationSuffix: colors.dim(`(${loc})`),
                             stackString: ''
                         };
-                        let parsedFrames = parse(item.stack), userFrame = parsedFrames.find((frame)=>frame.file && null !== frame.lineNumber && null !== frame.column && browserLogs_SCRIPT_REGEX.test(frame.file));
-                        if (userFrame) {
-                            let parsedUserFrame = await parseFrame(userFrame), loc = parsedUserFrame ? formatOriginalLocation(parsedUserFrame.originalPosition) : null;
-                            if (loc) return {
-                                locationSuffix: colors.dim(`(${loc})`),
-                                stackString: ''
-                            };
-                        }
-                        let formattedStack = await formatFullStack(parsedFrames);
-                        return {
-                            locationSuffix: '',
-                            stackString: colors.dim(formattedStack)
-                        };
-                    }, {
-                        name: 'unpack:browser-logs',
-                        apply: (config, { command })=>'dev' === command && config.dev?.browserLogs,
-                        buildStart: async ({ isFirstCompile, compiler })=>{
-                            isFirstCompile && (fs = compiler.outputFileSystem);
-                        },
-                        configResolved: (config)=>{
-                            rootPath = config.root, outputPath = node_path.join(rootPath, config.build.outDir), basePath = normalizePublicPath(config.base);
-                        },
-                        transformHtml: (html)=>injectToHead(html, `<script>
+                    }
+                    let formattedStack = await formatFullStack(parsedFrames);
+                    return {
+                        locationSuffix: '',
+                        stackString: colors.dim(formattedStack)
+                    };
+                }, {
+                    name: 'unpack:browser-logs',
+                    apply: (config, { command })=>'dev' === command && config.dev?.browserLogs,
+                    buildStart: async ({ isFirstCompile, compiler })=>{
+                        isFirstCompile && (fs = compiler.outputFileSystem);
+                    },
+                    configResolved: (config)=>{
+                        rootPath = config.root, outputPath = node_path.join(rootPath, config.build.outDir), basePath = normalizePublicPath(config.base);
+                    },
+                    transformHtml: (html)=>injectToHead(html, `<script>
 ;(() => {
   if (typeof window === 'undefined' || typeof console === 'undefined') return
   const endpoint = '${BROWSER_LOGS_ENDPOINT}'
@@ -1783,433 +1951,665 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
   })
 })()
 </script>`),
-                        setupMiddlewares: (middlewares)=>[
-                                (req, res, next)=>{
-                                    if ('POST' !== req.method || !req.url?.startsWith(BROWSER_LOGS_ENDPOINT)) return next();
-                                    let raw = '';
-                                    req.on('data', (chunk)=>{
-                                        raw += chunk.toString();
-                                    }), req.on('end', async ()=>{
-                                        try {
-                                            let { level, time, args = [] } = JSON.parse(raw || '{}'), formattedArgs = await Promise.all(args.map(async (item)=>{
-                                                if (!item) return '';
-                                                if ('error' === item.type) {
-                                                    let { locationSuffix, stackString } = await resolveErrorLocationAndStack(item), msg = item.message || '', suffix = locationSuffix ? msg ? ` ${locationSuffix}` : locationSuffix : '';
-                                                    return `${msg}${suffix}${stackString}`;
+                    setupMiddlewares: (middlewares)=>[
+                            (req, res, next)=>{
+                                if ('POST' !== req.method || !req.url?.startsWith(BROWSER_LOGS_ENDPOINT)) return next();
+                                let raw = '';
+                                req.on('data', (chunk)=>{
+                                    raw += chunk.toString();
+                                }), req.on('end', async ()=>{
+                                    try {
+                                        let { level, time, args = [] } = JSON.parse(raw || '{}'), formattedArgs = await Promise.all(args.map(async (item)=>{
+                                            if (!item) return '';
+                                            if ('error' === item.type) {
+                                                let { locationSuffix, stackString } = await resolveErrorLocationAndStack(item), msg = item.message || '', suffix = locationSuffix ? msg ? ` ${locationSuffix}` : locationSuffix : '';
+                                                return `${msg}${suffix}${stackString}`;
+                                            }
+                                            switch(item.type){
+                                                case 'string':
+                                                    let trimmed;
+                                                    return (trimmed = item.message.trim()) ? trimmed.split(/\r?\n/g).filter((line)=>{
+                                                        let normalized = line.trim().replace(/`/g, '');
+                                                        return !!normalized && !/^at\s+/.test(normalized);
+                                                    }).join('\n').trim() : '';
+                                                case 'null':
+                                                    return null;
+                                                case 'undefined':
+                                                    return;
+                                                case 'object':
+                                                    return JSON.parse(item.message || '');
+                                                default:
+                                                    return item.message;
+                                            }
+                                        })), outputArgs = ((args)=>{
+                                            if (args.length < 2 || 'string' != typeof args[0]) return args;
+                                            let template = args[0];
+                                            if (!/%[sdifoOj%c%]/.test(template)) return args;
+                                            let rest = args.slice(1), cleanedTemplate = '';
+                                            for(let i = 0; i < template.length; i++){
+                                                let ch = template[i];
+                                                if ('%' !== ch || i + 1 >= template.length) {
+                                                    cleanedTemplate += ch;
+                                                    continue;
                                                 }
-                                                switch(item.type){
-                                                    case 'string':
-                                                        let trimmed;
-                                                        return (trimmed = item.message.trim()) ? trimmed.split(/\r?\n/g).filter((line)=>{
-                                                            let normalized = line.trim().replace(/`/g, '');
-                                                            return !!normalized && !/^at\s+/.test(normalized);
-                                                        }).join('\n').trim() : '';
-                                                    case 'null':
-                                                        return null;
-                                                    case 'undefined':
-                                                        return;
-                                                    case 'object':
-                                                        return JSON.parse(item.message || '');
-                                                    default:
-                                                        return item.message;
+                                                let next = template[i + 1];
+                                                if ('%' === next) {
+                                                    cleanedTemplate += '%%', i++;
+                                                    continue;
                                                 }
-                                            })), outputArgs = ((args)=>{
-                                                if (args.length < 2 || 'string' != typeof args[0]) return args;
-                                                let template = args[0];
-                                                if (!/%[sdifoOj%c%]/.test(template)) return args;
-                                                let rest = args.slice(1), cleanedTemplate = '';
-                                                for(let i = 0; i < template.length; i++){
-                                                    let ch = template[i];
-                                                    if ('%' !== ch || i + 1 >= template.length) {
-                                                        cleanedTemplate += ch;
-                                                        continue;
-                                                    }
-                                                    let next = template[i + 1];
-                                                    if ('%' === next) {
-                                                        cleanedTemplate += '%%', i++;
-                                                        continue;
-                                                    }
-                                                    if ('c' === next) {
-                                                        rest.length > 0 && rest.shift(), i++;
-                                                        continue;
-                                                    }
-                                                    cleanedTemplate += `%${next}`, i++;
+                                                if ('c' === next) {
+                                                    rest.length > 0 && rest.shift(), i++;
+                                                    continue;
                                                 }
-                                                return [
-                                                    format(cleanedTemplate, ...rest)
-                                                ];
-                                            })(formattedArgs), prefix = colors.dim(`[browser ${time}]`);
-                                            switch(level){
-                                                case 'error':
-                                                    console.log(colors.red(`${prefix} ${format(...outputArgs)}`));
-                                                    break;
-                                                case 'warn':
-                                                    console.log(colors.yellow(`${prefix} ${format(...outputArgs)}`));
-                                                    break;
-                                                case 'debug':
-                                                    console.log(prefix, ...outputArgs);
+                                                cleanedTemplate += `%${next}`, i++;
                                             }
-                                        } finally{
-                                            res.statusCode = 204, res.end();
+                                            return [
+                                                format(cleanedTemplate, ...rest)
+                                            ];
+                                        })(formattedArgs), prefix = colors.dim(`[browser ${time}]`);
+                                        switch(level){
+                                            case 'error':
+                                                console.log(colors.red(`${prefix} ${format(...outputArgs)}`));
+                                                break;
+                                            case 'warn':
+                                                console.log(colors.yellow(`${prefix} ${format(...outputArgs)}`));
+                                                break;
+                                            case 'debug':
+                                                console.log(prefix, ...outputArgs);
                                         }
+                                    } finally{
+                                        res.statusCode = 204, res.end();
+                                    }
+                                });
+                            },
+                            ...middlewares
+                        ]
+                }),
+                {
+                    name: 'unpack:glob',
+                    transform: {
+                        filter: {
+                            test: JS_REGEX
+                        },
+                        handler: (code)=>code.includes('import.meta.glob') ? code.replace(/import\.meta\.glob\s*\(\s*(\[[\s\S]*?\]|(['"])([^'"]+)\2)\s*(?:,\s*({[\s\S]*?}))?\s*\)/g, (_, patternGroup, __, pattern, rawOptions)=>{
+                                if (patternGroup.trim().startsWith('[')) {
+                                    let items, includes, excludes, { includes: includes1, excludes: excludes1 } = (items = [], patternGroup.replace(/(['"])([^'"]+)\1/g, (_, __, value)=>(items.push(value), '')), includes = [], excludes = [], items.forEach((item)=>{
+                                        if (item.startsWith('!')) {
+                                            let normalized = item.slice(1).trim();
+                                            normalized && excludes.push(normalized);
+                                            return;
+                                        }
+                                        includes.push(item);
+                                    }), {
+                                        includes,
+                                        excludes
                                     });
-                                },
-                                ...middlewares
-                            ]
-                    }),
-                    (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 = {
-                        name: 'unpack:prebundle',
-                        apply: (config, { command })=>'dev' === command && !!config.dev?.prebundle,
-                        config: async (config, context)=>{
-                            var externals;
-                            let existExternals, root = config.root;
-                            bundledDepsCachePath = node_path.resolve(root, context.cachePath, 'umd');
-                            let count = {
-                                total: 0,
-                                bundled: 0
-                            }, failedDepsJsonPath = node_path.resolve(root, context.cachePath, 'failed-deps.json'), failedDeps = [], failedCache = node_fs.existsSync(failedDepsJsonPath) ? JSON.parse(node_fs.readFileSync(failedDepsJsonPath, 'utf-8')) : {}, updateProgress = ()=>{
-                                let errMsg = failedDeps.length > 0 ? ` failed: ${failedDeps.join(', ')}` : '';
-                                logUpdate(`${colors.magenta('»')} optimizing dependencies (${count.bundled}/${count.total})${errMsg}`), count.total === count.bundled + failedDeps.length && console.log();
-                            }, userOptions = isPlainObject(config.dev?.prebundle) ? config.dev.prebundle : {}, ignoreCSSDeps = userOptions.ignoreCSS || [], packageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'package.json'), 'utf-8')), excludeDeps = [
-                                ...(externals = config.externals, existExternals = new Set(), Array.isArray(externals) ? externals.forEach((item)=>{
-                                    isPlainObject(item) && Object.keys(item).forEach((key)=>{
-                                        existExternals.add(key);
-                                    });
-                                }) : isPlainObject(externals) && Object.keys(externals).forEach((key)=>{
+                                    return includes1.length ? (({ includes, excludes, eager })=>{
+                                        let excludeMatchers = excludes.map((item)=>toRegexLiteral(item.regExpSource)).join(', '), 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)} }),
+    mapKey: (key) => ${mapKeyExpr}
+  }`;
+                                        }).join(', '), excludeList = excludeMatchers ? `[${excludeMatchers}]` : '[]';
+                                        return `(() => {
+  const modules = {}
+  const includeContexts = [${includeItems}]
+  const excludeMatchers = ${excludeList}
+  const isExcluded = (path) => excludeMatchers.some((matcher) => matcher.test(path))
+  for (const { context, mapKey } of includeContexts) {
+    for (const key of context.keys()) {
+      const path = mapKey(key)
+      if (isExcluded(path)) continue
+      if (!modules[path]) {
+        modules[path] = ${eager ? 'context(key)' : '() => Promise.resolve(context(key))'}
+      }
+    }
+  }
+  return modules
+})()`;
+                                    })({
+                                        includes: includes1.map(parseGlob),
+                                        excludes: excludes1.map(parseGlob),
+                                        eager: hasEager(rawOptions)
+                                    }) : '({})';
+                                }
+                                let { baseDir, regExpSource, recursive, publicPrefix } = parseGlob(pattern);
+                                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 modules = {}
+  for (const key of context.keys()) {
+    const path = ${mapKeyExpr}
+    modules[path] = ${eager ? 'context(key)' : '() => Promise.resolve(context(key))'}
+  }
+  return modules
+})()`;
+                                })({
+                                    baseDir,
+                                    regExpSource,
+                                    recursive,
+                                    eager: hasEager(rawOptions),
+                                    publicPrefix
+                                });
+                            }) : 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 = {
+                    name: 'unpack:prebundle',
+                    apply: (config, { command })=>'dev' === command && !!config.dev?.prebundle,
+                    config: async (config, context)=>{
+                        var externals;
+                        let existExternals, root = config.root;
+                        bundledDepsCachePath = node_path.resolve(root, context.cachePath, 'umd');
+                        let count = {
+                            total: 0,
+                            bundled: 0
+                        }, failedDepsJsonPath = node_path.resolve(root, context.cachePath, 'failed-deps.json'), failedDeps = [], failedCache = node_fs.existsSync(failedDepsJsonPath) ? JSON.parse(node_fs.readFileSync(failedDepsJsonPath, 'utf-8')) : {}, updateProgress = ()=>{
+                            let errMsg = failedDeps.length > 0 ? ` failed: ${failedDeps.join(', ')}` : '';
+                            logUpdate(`${colors.magenta('»')} optimizing dependencies (${count.bundled}/${count.total})${errMsg}`), count.total === count.bundled + failedDeps.length && console.log();
+                        }, userOptions = isPlainObject(config.dev?.prebundle) ? config.dev.prebundle : {}, ignoreCSSDeps = userOptions.ignoreCSS || [], packageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'package.json'), 'utf-8')), excludeDeps = [
+                            ...(externals = config.externals, existExternals = new Set(), Array.isArray(externals) ? externals.forEach((item)=>{
+                                isPlainObject(item) && Object.keys(item).forEach((key)=>{
                                     existExternals.add(key);
-                                }), Array.from(existExternals) || []),
-                                ...userOptions.exclude || []
-                            ], needBundleDeps = (Array.isArray(userOptions.include) && userOptions.include.length > 0 ? userOptions.include : Object.keys(packageJson.dependencies || {})).filter((pkgName)=>!excludeDeps.includes(pkgName)).map((pkgName)=>{
-                                let depPackageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'node_modules', pkgName, 'package.json'), 'utf-8')), version = depPackageJson.version;
-                                if (failedCache[pkgName] === version) return;
-                                let entry = ((packageJson)=>{
-                                    if (packageJson.module) return packageJson.module;
-                                    if (packageJson.exports) {
-                                        if (isString(packageJson.exports)) return packageJson.exports;
-                                        let defaultExport = packageJson.exports['.'];
-                                        if (defaultExport) {
-                                            if (isString(defaultExport)) return defaultExport;
-                                            if (isString(defaultExport.import)) return defaultExport.import;
-                                            if (isString(defaultExport.browser)) return defaultExport.browser;
-                                            if (isString(defaultExport.default)) return defaultExport.default;
-                                        }
-                                        if (isString(packageJson.exports.default)) return packageJson.exports.default;
-                                    }
-                                    if (packageJson.main) return packageJson.main;
-                                })(depPackageJson);
-                                if (!entry) {
-                                    if (SPECIAL_NO_ENTRY_DEPS.includes(pkgName)) {
-                                        let syntheticEntry = (({ root, pkgName })=>{
-                                            let pkgDir = node_path.resolve(root, 'node_modules', pkgName);
-                                            if (!node_fs.existsSync(pkgDir)) return;
-                                            let indexPath = node_path.resolve(pkgDir, 'index.ts'), content = globSync('**/*.{js,jsx,ts,tsx}', {
-                                                cwd: pkgDir,
-                                                absolute: !1
-                                            }).filter((p)=>{
-                                                let base = node_path.basename(p);
-                                                return !(p.endsWith('.d.ts') || /^index\.(t|j)sx?$/.test(base)) && 'package.json' !== base;
-                                            }).map((file)=>{
-                                                let normalized = file.split(node_path.sep).join('/'), exportName = pathToExportIdentifier(normalized);
-                                                return `export { default as ${exportName} } from './${normalized}'`;
-                                            }).join('\n');
-                                            return node_fs.writeFileSync(indexPath, content, 'utf-8'), indexPath;
-                                        })({
-                                            root,
-                                            pkgName
-                                        });
-                                        if (syntheticEntry) return shouldTransformDeepImport = !0, {
-                                            name: pkgName,
-                                            entry: syntheticEntry,
-                                            version
-                                        };
+                                });
+                            }) : isPlainObject(externals) && Object.keys(externals).forEach((key)=>{
+                                existExternals.add(key);
+                            }), Array.from(existExternals) || []),
+                            ...userOptions.exclude || []
+                        ], needBundleDeps = (Array.isArray(userOptions.include) && userOptions.include.length > 0 ? userOptions.include : Object.keys(packageJson.dependencies || {})).filter((pkgName)=>!excludeDeps.includes(pkgName)).map((pkgName)=>{
+                            let depPackageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'node_modules', pkgName, 'package.json'), 'utf-8')), version = depPackageJson.version;
+                            if (failedCache[pkgName] === version) return;
+                            let entry = ((packageJson)=>{
+                                if (packageJson.module) return packageJson.module;
+                                if (packageJson.exports) {
+                                    if (isString(packageJson.exports)) return packageJson.exports;
+                                    let defaultExport = packageJson.exports['.'];
+                                    if (defaultExport) {
+                                        if (isString(defaultExport)) return defaultExport;
+                                        if (isString(defaultExport.import)) return defaultExport.import;
+                                        if (isString(defaultExport.browser)) return defaultExport.browser;
+                                        if (isString(defaultExport.default)) return defaultExport.default;
                                     }
-                                    failedCache[pkgName] = version;
-                                    return;
+                                    if (isString(packageJson.exports.default)) return packageJson.exports.default;
                                 }
-                                return {
-                                    name: pkgName,
-                                    entry: node_path.resolve(root, 'node_modules', pkgName, entry),
-                                    version
-                                };
-                            }).filter(Boolean), depExternals = Object.fromEntries(Array.from(new Set([
-                                'react',
-                                'react-dom',
-                                'react-router-dom',
-                                ...Array.isArray(userOptions.externals) ? userOptions.externals : []
-                            ])).map((pkg)=>[
-                                    pkg,
-                                    getExternalValue(pkg)
-                                ])), bundledDeps = await Promise.all(needBundleDeps.map((depInfo)=>(({ name, entry, version })=>new Promise((resolve)=>{
-                                        let pkgDir = node_path.resolve(bundledDepsCachePath, name), outDir = node_path.resolve(pkgDir, version), getResult = ()=>({
-                                                name,
-                                                assets: globSync('**/index.{js,css}', {
-                                                    cwd: outDir,
-                                                    absolute: !0
-                                                })
-                                            });
-                                        if (node_fs.existsSync(outDir)) return void resolve(getResult());
-                                        count.total++, updateProgress();
-                                        let getSwcOptions = ({ tsx })=>({
-                                                jsc: {
-                                                    parser: {
-                                                        tsx,
-                                                        syntax: "typescript",
-                                                        dynamicImport: !0,
-                                                        decorators: !0
-                                                    },
-                                                    transform: {
-                                                        react: {
-                                                            runtime: 'automatic'
-                                                        }
+                                if (packageJson.main) return packageJson.main;
+                            })(depPackageJson);
+                            if (!entry) {
+                                if (SPECIAL_NO_ENTRY_DEPS.includes(pkgName)) {
+                                    let syntheticEntry = (({ root, pkgName })=>{
+                                        let pkgDir = node_path.resolve(root, 'node_modules', pkgName);
+                                        if (!node_fs.existsSync(pkgDir)) return;
+                                        let indexPath = node_path.resolve(pkgDir, 'index.ts'), content = globSync('**/*.{js,jsx,ts,tsx}', {
+                                            cwd: pkgDir,
+                                            absolute: !1
+                                        }).filter((p)=>{
+                                            let base = node_path.basename(p);
+                                            return !(p.endsWith('.d.ts') || /^index\.(t|j)sx?$/.test(base)) && 'package.json' !== base;
+                                        }).map((file)=>{
+                                            let normalized = file.split(node_path.sep).join('/'), exportName = pathToExportIdentifier(normalized);
+                                            return `export { default as ${exportName} } from './${normalized}'`;
+                                        }).join('\n');
+                                        return node_fs.writeFileSync(indexPath, content, 'utf-8'), indexPath;
+                                    })({
+                                        root,
+                                        pkgName
+                                    });
+                                    if (syntheticEntry) return shouldTransformDeepImport = !0, {
+                                        name: pkgName,
+                                        entry: syntheticEntry,
+                                        version
+                                    };
+                                }
+                                failedCache[pkgName] = version;
+                                return;
+                            }
+                            return {
+                                name: pkgName,
+                                entry: node_path.resolve(root, 'node_modules', pkgName, entry),
+                                version
+                            };
+                        }).filter(Boolean), depExternals = Object.fromEntries(Array.from(new Set([
+                            ...FRAMEWORKS,
+                            ...Array.isArray(userOptions.externals) ? userOptions.externals : []
+                        ])).map((pkg)=>[
+                                pkg,
+                                getExternalValue(pkg)
+                            ])), bundledDeps = await Promise.all(needBundleDeps.map((depInfo)=>(({ name, entry, version })=>new Promise((resolve)=>{
+                                    let pkgDir = node_path.resolve(bundledDepsCachePath, name), outDir = node_path.resolve(pkgDir, version), getResult = ()=>({
+                                            name,
+                                            assets: globSync('**/index.{js,css}', {
+                                                cwd: outDir,
+                                                absolute: !0
+                                            })
+                                        });
+                                    if (node_fs.existsSync(outDir)) return void resolve(getResult());
+                                    count.total++, updateProgress();
+                                    let getSwcOptions = ({ tsx })=>({
+                                            jsc: {
+                                                parser: {
+                                                    tsx,
+                                                    syntax: "typescript",
+                                                    dynamicImport: !0,
+                                                    decorators: !0
+                                                },
+                                                transform: {
+                                                    react: {
+                                                        runtime: 'automatic'
                                                     }
                                                 }
-                                            }), compiler = rspack({
-                                            entry: {
-                                                index: entry
+                                            }
+                                        }), compiler = rspack({
+                                        entry: {
+                                            index: entry
+                                        },
+                                        context: root,
+                                        mode: 'development',
+                                        output: {
+                                            clean: !0,
+                                            path: outDir,
+                                            pathinfo: !1,
+                                            library: {
+                                                name: getExternalLibraryName(name),
+                                                type: 'umd',
+                                                umdNamedDefine: !0
                                             },
-                                            context: root,
-                                            mode: 'development',
-                                            output: {
-                                                clean: !0,
-                                                path: outDir,
-                                                pathinfo: !1,
-                                                library: {
-                                                    name: getExternalLibraryName(name),
-                                                    type: 'umd',
-                                                    umdNamedDefine: !0
+                                            globalObject: 'this'
+                                        },
+                                        devtool: !1,
+                                        module: {
+                                            rules: [
+                                                {
+                                                    test: /\.(png|jpe?g|gif|webp)$/i,
+                                                    type: 'asset'
                                                 },
-                                                globalObject: 'this'
-                                            },
-                                            devtool: !1,
-                                            module: {
-                                                rules: [
-                                                    {
-                                                        test: JS_REGEX,
-                                                        use: [
-                                                            {
-                                                                loader: 'builtin:swc-loader',
-                                                                options: getSwcOptions({
-                                                                    tsx: !1
-                                                                })
-                                                            }
-                                                        ]
-                                                    },
-                                                    {
-                                                        test: JSX_REGEX,
-                                                        use: [
-                                                            {
-                                                                loader: 'builtin:swc-loader',
-                                                                options: getSwcOptions({
-                                                                    tsx: !0
-                                                                })
-                                                            }
-                                                        ]
-                                                    },
-                                                    {
-                                                        test: /\.less$/,
-                                                        type: 'css/auto',
-                                                        use: [
-                                                            {
-                                                                loader: getCompiledPkgPath('less-loader'),
-                                                                options: {
-                                                                    lessOptions: {
-                                                                        javascriptEnabled: !0
-                                                                    },
-                                                                    implementation: getUserDepPath(root, 'less')
-                                                                }
+                                                {
+                                                    test: JS_REGEX,
+                                                    use: [
+                                                        {
+                                                            loader: 'builtin:swc-loader',
+                                                            options: getSwcOptions({
+                                                                tsx: !1
+                                                            })
+                                                        }
+                                                    ]
+                                                },
+                                                {
+                                                    test: JSX_REGEX,
+                                                    use: [
+                                                        {
+                                                            loader: 'builtin:swc-loader',
+                                                            options: getSwcOptions({
+                                                                tsx: !0
+                                                            })
+                                                        }
+                                                    ]
+                                                },
+                                                {
+                                                    test: /\.less$/,
+                                                    type: 'css/auto',
+                                                    use: [
+                                                        {
+                                                            loader: getCompiledPkgPath('less-loader'),
+                                                            options: {
+                                                                lessOptions: {
+                                                                    javascriptEnabled: !0
+                                                                },
+                                                                implementation: getUserDepPath(root, 'less')
                                                             }
-                                                        ]
-                                                    },
-                                                    {
-                                                        test: /\.s[ac]ss$/i,
-                                                        type: 'css/auto',
-                                                        use: [
-                                                            {
-                                                                loader: getCompiledPkgPath('sass-loader'),
-                                                                options: {
-                                                                    api: 'modern-compiler',
-                                                                    implementation: getUserDepPath(root, [
-                                                                        'sass-embedded',
-                                                                        'sass'
-                                                                    ])
-                                                                }
+                                                        }
+                                                    ]
+                                                },
+                                                {
+                                                    test: /\.s[ac]ss$/i,
+                                                    type: 'css/auto',
+                                                    use: [
+                                                        {
+                                                            loader: getCompiledPkgPath('sass-loader'),
+                                                            options: {
+                                                                api: 'modern-compiler',
+                                                                implementation: getUserDepPath(root, [
+                                                                    'sass-embedded',
+                                                                    'sass'
+                                                                ])
                                                             }
-                                                        ]
-                                                    }
-                                                ]
-                                            },
-                                            optimization: {
-                                                splitChunks: !1
-                                            },
-                                            experiments: {
-                                                css: !0
-                                            },
-                                            externals: depExternals
-                                        });
-                                        compiler.run((_, stats)=>{
-                                            let isFailed = !1;
-                                            stats?.hasErrors() ? (isFailed = !0, failedDeps.push(name), failedCache[name] = version, removeDir(outDir)) : count.bundled++, updateProgress(), compiler.close(()=>{
-                                                resolve(isFailed ? void 0 : getResult());
-                                            });
+                                                        }
+                                                    ]
+                                                }
+                                            ]
+                                        },
+                                        optimization: {
+                                            splitChunks: !1
+                                        },
+                                        experiments: {
+                                            css: !0
+                                        },
+                                        externals: depExternals
+                                    });
+                                    compiler.run((_, stats)=>{
+                                        let isFailed = !1;
+                                        stats?.hasErrors() ? (isFailed = !0, failedDeps.push(name), failedCache[name] = version, removeDir(outDir)) : count.bundled++, updateProgress(), compiler.close(()=>{
+                                            resolve(isFailed ? void 0 : getResult());
                                         });
-                                    }))(depInfo)));
-                            ((cache)=>{
-                                if (0 === Object.keys(cache).length) {
-                                    node_fs.existsSync(failedDepsJsonPath) && node_fs.unlinkSync(failedDepsJsonPath);
+                                    });
+                                }))(depInfo)));
+                        ((cache)=>{
+                            if (0 === Object.keys(cache).length) {
+                                node_fs.existsSync(failedDepsJsonPath) && node_fs.unlinkSync(failedDepsJsonPath);
+                                return;
+                            }
+                            let cacheDir = node_path.dirname(failedDepsJsonPath);
+                            node_fs.existsSync(cacheDir) || node_fs.mkdirSync(cacheDir, {
+                                recursive: !0
+                            }), node_fs.writeFileSync(failedDepsJsonPath, JSON.stringify(cache, null, 2), 'utf-8');
+                        })(failedCache);
+                        let externals1 = {};
+                        bundledDeps.filter(Boolean).forEach((dep)=>{
+                            dep && (externals1[dep.name] = getExternalValue(dep.name), dep.assets.forEach((absPath)=>{
+                                let relativePath = node_path.relative(bundledDepsCachePath, absPath), serverPath = `/umd/${relativePath}`;
+                                switch(node_path.extname(relativePath)){
+                                    case '.js':
+                                        FRAMEWORKS.includes(dep.name) ? preJsAssets.push({
+                                            path: serverPath,
+                                            order: FRAMEWORKS.indexOf(dep.name)
+                                        }) : jsAssets.push(serverPath);
+                                        break;
+                                    case '.css':
+                                        ignoreCSSDeps.includes(dep.name) || cssAssets.push(serverPath);
+                                }
+                            }));
+                        });
+                        let existingExternals = config.externals ? Array.isArray(config.externals) ? config.externals : [
+                            config.externals
+                        ] : [];
+                        return config.externals = [
+                            externals1,
+                            ...existingExternals
+                        ], shouldTransformDeepImport && (plugin.transform = {
+                            filter: {
+                                test: JSX_REGEX
+                            },
+                            handler: (code)=>SPECIAL_NO_ENTRY_DEPS.some((pkg)=>code.includes(pkg)) ? code.replace(deepImportRegex, (_, localName, importPath, pkgName)=>{
+                                    let exportName = pathToExportIdentifier(importPath.slice(pkgName.length + 1));
+                                    return `import { ${exportName} as ${localName} } from '${pkgName}'`;
+                                }) : null
+                        }), config;
+                    },
+                    transformHtml: (html)=>injectToHead(html, preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path).map((item)=>`<script defer src="${item}"></script>`).join('')),
+                    setupMiddlewares: (middlewares)=>[
+                            (req, res, next)=>{
+                                if ('string' != typeof req.url) return void next();
+                                let url = new URL(req.url, 'http://localhost');
+                                if (!url.pathname.startsWith("/umd/")) return void next();
+                                let relativePath = url.pathname.replace("/umd/", '');
+                                if (relativePath.includes('..')) {
+                                    res.statusCode = 403, res.end();
                                     return;
                                 }
-                                let cacheDir = node_path.dirname(failedDepsJsonPath);
-                                node_fs.existsSync(cacheDir) || node_fs.mkdirSync(cacheDir, {
-                                    recursive: !0
-                                }), node_fs.writeFileSync(failedDepsJsonPath, JSON.stringify(cache, null, 2), 'utf-8');
-                            })(failedCache);
-                            let externals1 = {};
-                            bundledDeps.filter(Boolean).forEach((dep)=>{
-                                dep && (externals1[dep.name] = getExternalValue(dep.name), dep.assets.forEach((absPath)=>{
-                                    let relativePath = node_path.relative(bundledDepsCachePath, absPath), preDeps = [
-                                        'react',
-                                        'react-dom',
-                                        'react-router-dom'
-                                    ], serverPath = `/umd/${relativePath}`;
-                                    switch(node_path.extname(relativePath)){
-                                        case '.js':
-                                            preDeps.includes(dep.name) ? preJsAssets.push({
-                                                path: serverPath,
-                                                order: preDeps.indexOf(dep.name)
-                                            }) : jsAssets.push(serverPath);
-                                            break;
-                                        case '.css':
-                                            ignoreCSSDeps.includes(dep.name) || cssAssets.push(serverPath);
-                                    }
-                                }));
+                                let filePath = node_path.join(bundledDepsCachePath, relativePath);
+                                if (!node_fs.existsSync(filePath)) return void next();
+                                let stat = node_fs.statSync(filePath);
+                                if (!stat.isFile()) return void next();
+                                let mtime = stat.mtime.toUTCString(), ext = node_path.extname(filePath);
+                                if (res.setHeader('Cache-Control', 'no-cache'), res.setHeader('Last-Modified', mtime), '.js' === ext && res.setHeader('Content-Type', "application/javascript"), '.css' === ext && res.setHeader('Content-Type', 'text/css'), req.headers['if-modified-since'] === mtime) {
+                                    res.statusCode = 304, res.end();
+                                    return;
+                                }
+                                res.statusCode = 200, node_fs.createReadStream(filePath).pipe(res);
+                            },
+                            ...middlewares
+                        ],
+                    bundlerConfig: (config)=>{
+                        let PLUGIN_NAME = 'InjectAssetsPlugin';
+                        return config.plugins.push({
+                            apply: (compiler)=>{
+                                compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+                                    rspack.HtmlRspackPlugin.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(PLUGIN_NAME, async (args)=>(args.assets.js.unshift(...jsAssets), args.assets.css.unshift(...cssAssets), args));
+                                });
+                            }
+                        }), config;
+                    }
+                }),
+                (root = '', {
+                    name: 'unpack:file-size',
+                    apply: (config, { mode })=>'production' === mode && config.performance?.printFileSize,
+                    configResolved (config) {
+                        root = config.root;
+                    },
+                    buildEnd: async (options)=>{
+                        let { stats } = options;
+                        if (stats.hasErrors()) return;
+                        let chunkGroups = [
+                            {
+                                type: 'HTML',
+                                color: 'green',
+                                chunks: []
+                            },
+                            {
+                                type: 'Assets',
+                                color: 'yellow',
+                                chunks: []
+                            },
+                            {
+                                type: 'CSS',
+                                color: 'magenta',
+                                chunks: []
+                            },
+                            {
+                                type: 'JS',
+                                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;
+                        logUpdate('computing gzip size...'), await Promise.all(assets.map(async ([assetName, value])=>{
+                            let content, compressedSize, filePath = assetName.split('?')[0];
+                            try {
+                                content = value.source();
+                            } catch  {
+                                content = node_fs.readFileSync(node_path.join(distPath, filePath));
+                            }
+                            let size = Buffer.byteLength(content);
+                            compressedSize = COMPRESSIBLE_REGEX.test(filePath) ? await getCompressedSize(content) : size, totalSize += size, totalCompressedSize += compressedSize;
+                            let chunk = {
+                                name: node_path.basename(filePath),
+                                path: `${distFolder}/${filePath}`,
+                                size,
+                                compressedSize
+                            };
+                            switch(chunk.path.length > longest && (longest = chunk.path.length), node_path.extname(filePath)){
+                                case '.html':
+                                    chunkGroupMap.HTML.chunks.push(chunk);
+                                    break;
+                                case '.css':
+                                    chunkGroupMap.CSS.chunks.push(chunk);
+                                    break;
+                                case '.js':
+                                case '.wasm':
+                                    chunkGroupMap.JS.chunks.push(chunk);
+                                    break;
+                                default:
+                                    chunkGroupMap.Assets.chunks.push(chunk);
+                            }
+                        })), logUpdate(`✓ computed gzip size (${assets.length})`), console.log();
+                        let sizePad = displaySize(totalSize).length, compressPad = displaySize(totalCompressedSize).length;
+                        chunkGroups.forEach((group)=>{
+                            group.chunks.sort((a, b)=>a.size - b.size).forEach((chunk)=>{
+                                let isLarge = 'JS' === group.type && chunk.size / 1000 > 500, relativeOutDir = node_path.dirname(chunk.path) + '/', log = colors.dim(relativeOutDir);
+                                log += colors[group.color](chunk.name.padEnd(longest + 2 - relativeOutDir.length)), log += colors[isLarge ? 'yellow' : 'dim'](displaySize(chunk.size).padStart(sizePad)), console.log(log += colors.dim(` │ gzip: ${displaySize(chunk.compressedSize).padStart(compressPad)}`));
+                            });
+                        });
+                        let log = colors.blue('Total'.padEnd(longest + 2));
+                        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([
+                    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)=>{
+                        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'
                             });
-                            let existingExternals = config.externals ? Array.isArray(config.externals) ? config.externals : [
-                                config.externals
-                            ] : [];
-                            return config.externals = [
-                                externals1,
-                                ...existingExternals
-                            ], shouldTransformDeepImport && (plugin.transform = {
-                                filter: {
-                                    test: JSX_REGEX
-                                },
-                                handler: (code)=>SPECIAL_NO_ENTRY_DEPS.some((pkg)=>code.includes(pkg)) ? code.replace(deepImportRegex, (_, localName, importPath, pkgName)=>{
-                                        let exportName = pathToExportIdentifier(importPath.slice(pkgName.length + 1));
-                                        return `import { ${exportName} as ${localName} } from '${pkgName}'`;
-                                    }) : null
-                            }), config;
+                            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);
+                }, 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:\\"\\'\\\`\\\\}`}`;
+                }, 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);
+                    return `00000${(hVal >>> 0).toString(36)}`.slice(-6);
+                }, restoreSkipCode = (code, map)=>{
+                    let next = code;
+                    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;
+                    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)=>{
+                        let next = code;
+                        for (let item of Array.from(next.matchAll(rules)))if (null != item) {
+                            let matched = item[0], withHashKey = `${keyFlag}${hash(matched)}`;
+                            map.set(withHashKey, matched), next = next.replace(matched, withHashKey);
+                        }
+                        return next;
+                    })(code, skipMap, SKIP_COMMENT_RE, '@unocss-skip-placeholder-'));
+                    for (let t of transformers)(!t.idFilter || t.idFilter(id)) && (await t.transform(s, id, {
+                        uno,
+                        tokens,
+                        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), {
+                    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;
+                            configOrPathFromUnpackConfig = configOrPathValue, defaultsFromUnpackConfig = defaultsValue;
+                        }
+                        await ensureReady();
+                    },
+                    bundlerConfig: (config)=>(config.lazyCompilation = !1, config),
+                    buildStart ({ compiler }) {
+                        compilerRef = compiler;
+                    },
+                    transform: {
+                        filter: {
+                            test: /\.(vue|svelte|[jt]sx?|vine\.ts|mdx?|astro|elm|php|phtml|marko)($|\?)/
                         },
-                        transformHtml: (html)=>injectToHead(html, preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path).map((item)=>`<script defer src="${item}"></script>`).join('')),
-                        setupMiddlewares: (middlewares)=>[
-                                (req, res, next)=>{
-                                    if ('string' != typeof req.url) return void next();
-                                    let url = new URL(req.url, 'http://localhost');
-                                    if (!url.pathname.startsWith("/umd/")) return void next();
-                                    let relativePath = url.pathname.replace("/umd/", '');
-                                    if (relativePath.includes('..')) {
-                                        res.statusCode = 403, res.end();
-                                        return;
+                        handler: async (code, id)=>{
+                            var task;
+                            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;
                                     }
-                                    let filePath = node_path.join(bundledDepsCachePath, relativePath);
-                                    if (!node_fs.existsSync(filePath)) return void next();
-                                    let stat = node_fs.statSync(filePath);
-                                    if (!stat.isFile()) return void next();
-                                    let mtime = stat.mtime.toUTCString(), ext = node_path.extname(filePath);
-                                    if (res.setHeader('Cache-Control', 'no-cache'), res.setHeader('Last-Modified', mtime), '.js' === ext && res.setHeader('Content-Type', "application/javascript"), '.css' === ext && res.setHeader('Content-Type', 'text/css'), req.headers['if-modified-since'] === mtime) {
-                                        res.statusCode = 304, res.end();
-                                        return;
-                                    }
-                                    res.statusCode = 200, node_fs.createReadStream(filePath).pipe(res);
-                                },
-                                ...middlewares
-                            ],
-                        bundlerConfig: (config)=>{
-                            let PLUGIN_NAME = 'InjectAssetsPlugin';
-                            return config.plugins.push({
-                                apply: (compiler)=>{
-                                    compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
-                                        rspack.HtmlRspackPlugin.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(PLUGIN_NAME, async (args)=>(args.assets.js.unshift(...jsAssets), args.assets.css.unshift(...cssAssets), args));
-                                    });
-                                }
-                            }), config;
+                                })(layer);
+                                return requestedLayers.add(decodedLayer), `${quote}${getVirtualLayerId(decodedLayer)}${quote}`;
+                            })), task = async ()=>{
+                                await uno.applyExtractors(code.replace(SKIP_COMMENT_RE, ''), id, tokens);
+                            }, tasks.push(task), transformedCode === code ? null : transformedCode;
                         }
-                    }),
-                    (root = '', {
-                        name: 'unpack:file-size',
-                        apply: (config, { mode })=>'production' === mode && config.performance?.printFileSize,
-                        configResolved (config) {
-                            root = config.root;
-                        },
-                        buildEnd: async (options)=>{
-                            let { stats } = options;
-                            if (stats.hasErrors()) return;
-                            let chunkGroups = [
-                                {
-                                    type: 'HTML',
-                                    color: 'green',
-                                    chunks: []
-                                },
-                                {
-                                    type: 'Assets',
-                                    color: 'yellow',
-                                    chunks: []
-                                },
-                                {
-                                    type: 'CSS',
-                                    color: 'magenta',
-                                    chunks: []
-                                },
-                                {
-                                    type: 'JS',
-                                    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;
-                            logUpdate('computing gzip size...'), await Promise.all(assets.map(async ([assetName, value])=>{
-                                let content, compressedSize, filePath = assetName.split('?')[0];
-                                try {
-                                    content = value.source();
-                                } catch  {
-                                    content = node_fs.readFileSync(node_path.join(distPath, filePath));
-                                }
-                                let size = Buffer.byteLength(content);
-                                compressedSize = COMPRESSIBLE_REGEX.test(filePath) ? await getCompressedSize(content) : size, totalSize += size, totalCompressedSize += compressedSize;
-                                let chunk = {
-                                    name: node_path.basename(filePath),
-                                    path: `${distFolder}/${filePath}`,
-                                    size,
-                                    compressedSize
-                                };
-                                switch(chunk.path.length > longest && (longest = chunk.path.length), node_path.extname(filePath)){
-                                    case '.html':
-                                        chunkGroupMap.HTML.chunks.push(chunk);
-                                        break;
-                                    case '.css':
-                                        chunkGroupMap.CSS.chunks.push(chunk);
-                                        break;
-                                    case '.js':
-                                    case '.wasm':
-                                        chunkGroupMap.JS.chunks.push(chunk);
-                                        break;
-                                    default:
-                                        chunkGroupMap.Assets.chunks.push(chunk);
-                                }
-                            })), logUpdate(`✓ computed gzip size (${assets.length})`), console.log();
-                            let sizePad = displaySize(totalSize).length, compressPad = displaySize(totalCompressedSize).length;
-                            chunkGroups.forEach((group)=>{
-                                group.chunks.sort((a, b)=>a.size - b.size).forEach((chunk)=>{
-                                    let isLarge = 'JS' === group.type && chunk.size / 1000 > 500, relativeOutDir = node_path.dirname(chunk.path) + '/', log = colors.dim(relativeOutDir);
-                                    log += colors[group.color](chunk.name.padEnd(longest + 2 - relativeOutDir.length)), log += colors[isLarge ? 'yellow' : 'dim'](displaySize(chunk.size).padStart(sizePad)), console.log(log += colors.dim(` │ gzip: ${displaySize(chunk.compressedSize).padStart(compressPad)}`));
-                                });
+                    },
+                    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
                             });
-                            let log = colors.blue('Total'.padEnd(longest + 2));
-                            log += colors.blue(displaySize(totalSize)), console.log(log += colors.dim(` │ gzip: ${displaySize(totalCompressedSize)}`));
+                            for (let file of Object.keys(compilation.assets)){
+                                if ('*' === file || file.includes('vendor')) 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) || '';
+                                    return isJsAsset ? getCssEscaperForJsContent(escapeView)(css) : css;
+                                }), replaced && compilation.updateAsset(file, new sources.RawSource(code));
+                            }
                         }
-                    })
-                ]
-            }, userConfig),
+                    },
+                    virtualModules: ()=>({
+                            [VIRTUAL_UNO_CSS_ID]: getVirtualModuleContent(LAYER_MARK_ALL),
+                            ...getResolvedLayers().reduce((acc, layer)=>(acc[getVirtualLayerId(layer)] = getVirtualModuleContent(layer), acc), {})
+                        })
+                }),
+                (rootPath1 = '', registerCode = '', namesCode = '', {
+                    name: 'unpack:svg-icons',
+                    apply: (config)=>!!config.svgIcons,
+                    configResolved: (config)=>{
+                        rootPath1 = config.root || process.cwd(), optionsFromUnpackConfig = config.svgIcons, (()=>{
+                            let root, resolvedOptions = (void 0) ?? optionsFromUnpackConfig, inject = resolvedOptions.inject || 'body-last', domId = resolvedOptions.customDomId || '__svg__icons__dom__', { svg, names } = ((iconDirs, symbolId, customDomId)=>{
+                                let symbols = [], names = [], idSet = new Set();
+                                for (let dir of iconDirs)for (let file of readSvgFiles(dir)){
+                                    let { inner, viewBox } = extractSvgContent(normalizeSvg(node_fs.readFileSync(file, 'utf-8'))), id = toSymbolId(file, dir, symbolId);
+                                    !id || idSet.has(id) || (idSet.add(id), names.push(id), symbols.push(`<symbol id="${id}"${viewBox ? ` viewBox="${viewBox}"` : ''}>${inner}</symbol>`));
+                                }
+                                return {
+                                    svg: `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" id="${customDomId}" style="position: absolute; width: 0; height: 0" aria-hidden="true">${symbols.join('')}</svg>`,
+                                    names
+                                };
+                            })((root = rootPath1, (resolvedOptions.iconDirs || []).map((dir)=>node_path.isAbsolute(dir) ? dir : node_path.resolve(root, dir))), resolvedOptions.symbolId, domId);
+                            registerCode = `const svgDomId = ${JSON.stringify(domId)}\nconst svgHtml = ${JSON.stringify(svg)}\nconst inject = (position) => {\n  if (typeof document === 'undefined') return\n  if (document.getElementById(svgDomId)) return\n  const div = document.createElement('div')\n  div.innerHTML = svgHtml\n  const svgEl = div.firstElementChild\n  if (!svgEl) return\n  if (position === 'head' && document.head) {\n    document.head.prepend(svgEl)\n    return\n  }\n  const body = document.body\n  if (!body) return\n  if (position === 'body-first' && body.firstChild) {\n    body.insertBefore(svgEl, body.firstChild)\n  } else {\n    body.appendChild(svgEl)\n  }\n}\nconst mount = () => inject(${JSON.stringify(inject)})\nif (typeof document !== 'undefined') {\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', mount)\n  } else {\n    mount()\n  }\n}\nexport default mount`, namesCode = `export const svgIconNames = ${JSON.stringify(names)}\nexport default svgIconNames`;
+                        })();
+                    },
+                    virtualModules: ()=>({
+                            '~svg-icons-register': registerCode || 'export default null',
+                            '~svg-icons-names': namesCode || 'export default []'
+                        }),
+                    transform: {
+                        filter: {
+                            test: JS_REGEX
+                        },
+                        handler: (code)=>code.includes('virtual:svg-icons-') ? code.replace('virtual:svg-icons-', '~svg-icons-') : null
+                    }
+                })
+            ]
+        };
+        return {
+            ...utils_mergeConfig(defaultConfig, userConfig),
             _context
         };
     };
@@ -2218,7 +2618,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.0.0${config.performance?.cache ? ' ϟ' : ''}`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v4.2.0`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
             setUnpackStartTime(performance.now());
@@ -2236,7 +2636,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
 let GLOB_REGEX = /[*?{}[\]()!@+|]/;
 async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
     let watchFiles = new Set(), globPatterns = pathOrGlobs.filter((pathOrGlob)=>!!GLOB_REGEX.test(pathOrGlob) || (watchFiles.add(pathOrGlob), !1));
-    if (globPatterns.length) for (let file of (await glob(globPatterns, {
+    if (globPatterns.length) for (let file of (await external_tinyglobby_glob(globPatterns, {
         cwd: root,
         absolute: !0
     })))watchFiles.add(file);
@@ -2246,6 +2646,14 @@ async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
         ...options
     });
 }
+var injectFramework_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+async function injectFrameworkPluginForDebug(userConfig) {
+    var plugin;
+    let raw, framework, framework1 = (raw = process.env.FRAMEWORK, (framework = raw?.trim().toLowerCase()) ? 'react' === framework || 'vue' === framework ? framework : (logger_logger.warn(`Unknown FRAMEWORK "${raw}", fallback to "react".`), 'react') : 'react'), pluginPath = node_path.resolve(injectFramework_dirname, `../../plugin-${framework1}/dist/index.js`);
+    node_fs.existsSync(pluginPath) && (plugin = (0, (await import(pluginPath))[`plugin${framework1.charAt(0).toUpperCase() + framework1.slice(1)}`])(), userConfig.plugins ? userConfig.plugins.unshift(plugin) : userConfig.plugins = [
+        plugin
+    ]);
+}
 async function setupCliShortcuts({ help = !0, openPage, closeServer, printUrls, restartServer }) {
     let shortcuts = [
         restartServer ? {
@@ -2298,7 +2706,6 @@ async function setupCliShortcuts({ help = !0, openPage, closeServer, printUrls,
         for (let shortcut of shortcuts)if (input === shortcut.key) return void shortcut.action();
     }), addRestartCleaner(()=>rl.close());
 }
-var cli_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 let withErrorHandling = (action)=>async (options)=>{
         try {
             await action(options);
@@ -2311,14 +2718,8 @@ async function setupUnpack(cliOptions, command) {
     let userConfig = await loadConfig({
         cliOptions,
         command
-    }), pluginReactPath = node_path.resolve(cli_dirname, '../../plugin-react/dist/index.js');
-    if (node_fs.existsSync(pluginReactPath)) {
-        let { pluginReact } = await import(pluginReactPath);
-        userConfig.plugins ? userConfig.plugins.unshift(pluginReact()) : userConfig.plugins = [
-            pluginReact()
-        ];
-    }
-    return {
+    });
+    return await injectFrameworkPluginForDebug(userConfig), {
         unpack: createUnpack({
             cwd: userConfig.root,
             config: userConfig
@@ -2366,7 +2767,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.0.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.0"), cli.parse();
 }
 var src_CSS_MODULES_NAMED_EXPORT = !1;
-export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, esVersionToBrowserslist, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, 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, 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 };
+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 };