npm - @unpackjs/core - Versions diffs - 3.7.8 → 3.8.1 - Mend

@unpackjs/core 3.7.8 → 3.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

package/compiled/css-loader/index.js +20 -20
package/compiled/less-loader/index.js +8 -8
package/compiled/postcss-loader/index.js +11 -11
package/compiled/sass-loader/index.js +8 -8
package/dist/index.js +870 -562
package/dist/rslib-runtime.js +15 -0
package/dist/transformLoader.js +11 -0
package/dist/{typedCssModulesLoader.mjs → typedCssModulesLoader.js} +5 -13
package/dist-types/bundler-config/cache.d.ts.map +1 -1
package/dist-types/bundler-config/html.d.ts +6 -0
package/dist-types/bundler-config/html.d.ts.map +1 -0
package/dist-types/bundler-config/index.d.ts.map +1 -1
package/dist-types/bundler-config/loaders/transformLoader.d.ts +5 -0
package/dist-types/bundler-config/loaders/transformLoader.d.ts.map +1 -0
package/dist-types/bundler-config/plugins/progress/helpers.d.ts.map +1 -1
package/dist-types/bundler-config/plugins/progress/index.d.ts +2 -2
package/dist-types/bundler-config/plugins/progress/index.d.ts.map +1 -1
package/dist-types/bundler-config/plugins/registerHooks.d.ts +6 -0
package/dist-types/bundler-config/plugins/registerHooks.d.ts.map +1 -0
package/dist-types/constants.d.ts +3 -0
package/dist-types/constants.d.ts.map +1 -1
package/dist-types/createUnpack.d.ts +4 -1
package/dist-types/createUnpack.d.ts.map +1 -1
package/dist-types/global.d.ts +4 -2
package/dist-types/global.d.ts.map +1 -1
package/dist-types/index.d.ts +1 -0
package/dist-types/index.d.ts.map +1 -1
package/dist-types/plugin.d.ts +4 -1
package/dist-types/plugin.d.ts.map +1 -1
package/dist-types/plugins/browserLogs.d.ts +3 -0
package/dist-types/plugins/browserLogs.d.ts.map +1 -0
package/dist-types/plugins/fileSize.d.ts +3 -0
package/dist-types/plugins/fileSize.d.ts.map +1 -0
package/dist-types/plugins/prebundle.d.ts +3 -0
package/dist-types/plugins/prebundle.d.ts.map +1 -0
package/dist-types/run/dev.d.ts +4 -1
package/dist-types/run/dev.d.ts.map +1 -1
package/dist-types/types/config.d.ts +24 -26
package/dist-types/types/config.d.ts.map +1 -1
package/dist-types/types/plugin.d.ts +23 -2
package/dist-types/types/plugin.d.ts.map +1 -1
package/dist-types/utils.d.ts +13 -1
package/dist-types/utils.d.ts.map +1 -1
package/package.json +9 -7
package/dist/transformDeepImportLoader.mjs +0 -82
package/dist-types/bundler-config/loaders/transformDeepImportLoader.d.ts +0 -5
package/dist-types/bundler-config/loaders/transformDeepImportLoader.d.ts.map +0 -1
package/dist-types/prebundleDeps.d.ts +0 -5
package/dist-types/prebundleDeps.d.ts.map +0 -1
package/dist-types/reporter.d.ts +0 -8
package/dist-types/reporter.d.ts.map +0 -1

package/dist/index.js CHANGED Viewed

@@ -5,37 +5,31 @@ import { fileURLToPath as __rspack_fileURLToPath, pathToFileURL } from "node:url
 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_readline from "node:readline";
 import node_fs from "node:fs";
 import node_net from "node:net";
 import node_os, { platform } from "node:os";
 import portfinder from "portfinder";
+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 { expand } from "dotenv-expand";
 import node_assert from "node:assert";
-import { glob, globSync } from "tinyglobby";
-import { promisify } from "node:util";
-import node_zlib from "node:zlib";
 import { RspackDevServer } from "@rspack/dev-server";
 import { exec, spawn } from "node:child_process";
-import node_http from "node:http";
 import chokidar from "chokidar";
-var LogColor, __webpack_modules__ = {
+__webpack_require__.add({
     "compiled/launch-editor" (module) {
         module.exports = __rspack_external__compiled_launch_editor_index_js_29002383;
     },
     "compiled/webpack-merge" (module) {
         module.exports = __rspack_external__compiled_webpack_merge_index_js_efd91626;
     }
-}, __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
-}
+});
 let isCI = !!process.env.CI, isTTY = !!process.stdout?.isTTY, noColor = !!process.env.NO_COLOR, forceColor = !!process.env.FORCE_COLOR, disableColor = !1;
 disableColor = !!noColor || !forceColor && (isCI || !isTTY);
 let ANSI_SGR_RE = /\x1b\[[0-9;]*m/g, ANSI_OPEN_RE = /\x1b\[([0-9;]+)m/g, COLOR_HEX = {
@@ -106,10 +100,12 @@ let restartCleaners = [], addRestartCleaner = (...cleaners)=>{
     restartCleaners.push(...cleaners);
 }, cleanUpBeforeRestart = async ()=>{
     await Promise.all(restartCleaners.map((cleaner)=>cleaner())), restartCleaners.length = 0;
-}, currentDevUnpackConfig = {}, setCurrentDevUnpackConfig = (config)=>{
-    currentDevUnpackConfig = config;
+}, currentUnpackConfig = {}, getCurrentUnpackConfig = ()=>currentUnpackConfig, setCurrentUnpackConfig = (config)=>{
+    currentUnpackConfig = config;
+}, unpackStartTime = 0, getUnpackStartTime = ()=>unpackStartTime, setUnpackStartTime = (time)=>{
+    unpackStartTime = time;
 };
-var logger_LogColor = ((LogColor = {}).error = "red", LogColor.warn = "yellow", LogColor.info = "cyan", LogColor.ready = "green", LogColor.event = "magenta", LogColor.wait = "blue", LogColor);
+var LogColor, logger_LogColor = ((LogColor = {}).error = "red", LogColor.warn = "yellow", LogColor.info = "cyan", LogColor.ready = "green", LogColor.event = "magenta", LogColor.wait = "blue", LogColor);
 let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULES_REGEX = /\.module\.\w+$/i, DEV_DEFAULT_FILENAME = {
     js: 'js/[name].js',
     jsAsync: 'js/async/[name].js',
@@ -121,22 +117,17 @@ let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULE
     css: 'css/[name].[contenthash:8].css',
     cssAsync: 'css/async/[name].[contenthash:8].css'
 }, EXPORT_LOCALS_CONVENTION = 'camel-case-only', NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/, DEFAULT_DEV_HOST = '0.0.0.0', TEMPLATE_CONTENT = ({ title = '', headTag = '', mountId = '' })=>`<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="UTF-8" />
-	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-	<title>
-		${title}
-	</title>
-	${headTag}
-</head>
-<body>
-	<div id="${mountId}"></div>
-</body>
-</html>`;
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    ${headTag}
+  </head>
+  <body>
+    <div id="${mountId}"></div>
+  </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)=>{
     process.env.NODE_ENV = env;
@@ -169,7 +160,11 @@ let { merge: mergeConfig } = __webpack_require__("compiled/webpack-merge"), { de
         }, (_, port)=>{
             resolve(port);
         });
-    }), getCompiledPkgPath = (packageName)=>node_path.join(utils_dirname, '../compiled', packageName), getUserDepPath = (root, deps)=>{
+    }), normalizePublicPath = (base)=>{
+    if (!base) return '/';
+    let normalized = base;
+    return normalized.startsWith('/') || (normalized = `/${normalized}`), normalized.endsWith('/') || (normalized = `${normalized}/`), normalized;
+}, getCompiledPkgPath = (packageName)=>node_path.join(utils_dirname, '../compiled', packageName), getUserDepPath = (root, deps)=>{
     for (let dep of Array.isArray(deps) ? deps : [
         deps
     ]){
@@ -200,14 +195,15 @@ let debounce = (fn, delay)=>{
         '127.0.0.1',
         '::1',
         '0000:0000:0000:0000:0000:0000:0000:0001'
-    ].includes(host), concatUrl = ({ host, port, protocol })=>`${protocol}://${host}:${port}/`, LOCAL_LABEL = 'Local:   ', NETWORK_LABEL = 'Network: ', getAddressUrls = ({ protocol = 'http', port, host })=>{
+    ].includes(host), concatUrl = ({ host, port, protocol, base })=>`${protocol}://${host}:${port}${normalizePublicPath(base)}`, LOCAL_LABEL = 'Local:   ', NETWORK_LABEL = 'Network: ', getAddressUrls = ({ protocol = 'http', port, host, base })=>{
     if (host && host !== DEFAULT_DEV_HOST) return [
         {
             label: isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL,
             url: concatUrl({
                 port,
                 host: node_net.isIPv6(host) ? '::' === host ? '[::1]' : `[${host}]` : host,
-                protocol
+                protocol,
+                base
             })
         }
     ];
@@ -219,7 +215,8 @@ let debounce = (fn, delay)=>{
             url: concatUrl({
                 host: 'localhost',
                 port,
-                protocol
+                protocol,
+                base
             })
         }), hasLocalUrl = !0;
     } else addressUrls.push({
@@ -227,7 +224,8 @@ let debounce = (fn, delay)=>{
         url: concatUrl({
             host: detail.address,
             port,
-            protocol
+            protocol,
+            base
         })
     });
     return addressUrls;
@@ -314,7 +312,33 @@ function pLimit(concurrency = Math.max(1, node_os.cpus().length - 1)) {
 let pathToExportIdentifier = (path)=>{
     let name = path.replace(/[^a-zA-Z0-9_$]+([a-zA-Z0-9_$])/g, (_, char)=>char.toUpperCase()).replace(/[^a-zA-Z0-9_$]/g, '');
     return (!(name = name.charAt(0).toUpperCase() + name.slice(1)) || /^[^a-zA-Z_$]/.test(name)) && (name = `_${name}`), name;
-}, logger_prefixes = {
+};
+function printServerUrls({ port, host, base }) {
+    let addressUrls = getAddressUrls({
+        port,
+        base
+    }), colorPrefix = colors.brand('➜');
+    addressUrls.forEach((addr, index)=>{
+        let url;
+        if (!host && 0 !== index) {
+            1 === index && console.log(`  ${colors.dim(colorPrefix)}  ${colors.bold(colors.dim('Network:'))} ${colors.dim('use')} ${colors.bold('--host')} ${colors.dim('to expose')}`);
+            return;
+        }
+        console.log(`  ${colorPrefix}  ${colors.bold(addr.label)}${(url = addr.url, colors.cyan(url.replace(/:(\d+)\//, (_, port)=>`:${colors.bold(port)}/`)))}`);
+    });
+}
+function getHtmlTemplateOrContent(rawTemplate, root) {
+    let template, templateContent;
+    if ('string' == typeof rawTemplate) {
+        let absPath = node_path.isAbsolute(rawTemplate) ? rawTemplate : node_path.resolve(root, rawTemplate);
+        node_fs.existsSync(absPath) ? template = rawTemplate : templateContent = rawTemplate;
+    } else templateContent = 'function' == typeof rawTemplate ? rawTemplate : TEMPLATE_CONTENT;
+    return {
+        template,
+        templateContent
+    };
+}
+let injectToHead = (html, script)=>html.replace(/<head(\s*[^>]*)>/i, (match)=>`${match}${script}`), logger_prefixes = {
     wait: '○',
     error: '⨯',
     warn: '⚠',
@@ -507,13 +531,44 @@ let removeDir = (dir)=>{
         recursive: !0,
         force: !0
     });
-}, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
-function getNormalizedPluginsByHook(hook, plugins) {
+}, 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', {
+    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 = [
+    '@iconify-icons/material-symbols'
+], 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;
+function getNormalizedPluginsByHook(hook) {
     let pluginMap = new Map();
-    return plugins?.forEach((plugin)=>{
-        plugin[hook] && pluginMap.set(plugin.name, plugin);
+    return getCurrentUnpackConfig().plugins?.forEach((plugin)=>{
+        ((plugin, hook)=>{
+            if (!plugin[hook]) return !1;
+            let apply = plugin.apply;
+            if (!apply) return !0;
+            let env = {
+                mode: getNodeEnv(),
+                command: utils_isDevServer() ? 'dev' : 'build'
+            };
+            return 'string' == typeof apply ? apply === env.command : !!apply(getCurrentUnpackConfig(), env);
+        })(plugin, hook) && pluginMap.set(plugin.name, plugin);
     }), Array.from(pluginMap.values());
 }
+async function applyPluginsByHook(hook, runner) {
+    for (let plugin of getNormalizedPluginsByHook(hook)){
+        let impl = plugin[hook];
+        await runner(impl);
+    }
+}
 async function applyBuildAnalyzeConfig({ config }) {
     let { RsdoctorRspackPlugin } = await import("@rsdoctor/rspack-plugin");
     return config.plugins?.push(new RsdoctorRspackPlugin()), config;
@@ -542,7 +597,7 @@ async function getBuildDependencies(root) {
     ]), buildDependencies;
 }
 async function applyCacheConfig({ config, unpackConfig, envFilePaths }) {
-    let cacheConfig = isPlainObject(unpackConfig.build.cache) ? unpackConfig.build.cache : {}, buildDependencies = await getBuildDependencies(unpackConfig.root);
+    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, {
@@ -656,20 +711,40 @@ let getOutputFilename = ({ type, hash, async })=>{
     return async ? 'js' === type ? FILENAME.jsAsync : FILENAME.cssAsync : FILENAME[type];
 };
 var css_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-function _define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
+async function applyHtmlConfig({ config, unpackConfig }) {
+    if (!unpackConfig.mpa) {
+        let htmlConfig = unpackConfig.html || {}, { template, templateContent } = getHtmlTemplateOrContent(htmlConfig.template, unpackConfig.root), templateParameters = {
+            mountId: htmlConfig.mountId,
+            title: isFunction(htmlConfig.title) ? htmlConfig.title({
+                entryName: 'index'
+            }) : htmlConfig.title || '',
+            headTag: htmlConfig.headTag || '',
+            ...htmlConfig.templateParameters
+        };
+        config.plugins.push(new rspack.HtmlRspackPlugin({
+            template,
+            templateContent,
+            templateParameters,
+            minify: !1,
+            chunks: [
+                'main'
+            ]
+        }));
+    }
+    return config;
 }
-let { RawSource, SourceMapSource } = rspack.sources, isJsFile = /\.[cm]?js(\?.*)?$/i, jsMinify_PLUGIN_NAME = 'JsMinifyPlugin';
+let { RawSource: RawSource, SourceMapSource: SourceMapSource } = rspack.sources, isJsFile = /\.[cm]?js(\?.*)?$/i, jsMinify_PLUGIN_NAME = 'JsMinifyPlugin';
 class JsMinifyPlugin {
+    minifyOptions;
+    customMinify;
+    constructor(options = {}){
+        let { implementation, ...minifyOptions } = options;
+        this.customMinify = implementation?.minify, this.minifyOptions = minifyOptions;
+    }
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "3.7.8",
+            version: "3.8.1",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -703,21 +778,23 @@ class JsMinifyPlugin {
             }
         }));
     }
-    constructor(options = {}){
-        _define_property(this, "minifyOptions", void 0), _define_property(this, "customMinify", void 0);
-        let { implementation, ...minifyOptions } = options;
-        this.customMinify = implementation?.minify, this.minifyOptions = minifyOptions;
-    }
-}
-function loadingAnimation_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
 }
 class LoadingAnimation {
+    chars = [
+        '⠋',
+        '⠙',
+        '⠹',
+        '⠸',
+        '⠼',
+        '⠴',
+        '⠦',
+        '⠧',
+        '⠇',
+        '⠏'
+    ];
+    currentIndex = 0;
+    lastUpdateTime = 0;
+    interval = 100;
     getCurrentChar() {
         let now = Date.now();
         return now - this.lastUpdateTime >= this.interval && (this.currentIndex = (this.currentIndex + 1) % this.chars.length, this.lastUpdateTime = now), this.chars[this.currentIndex];
@@ -725,110 +802,16 @@ class LoadingAnimation {
     reset() {
         this.currentIndex = 0, this.lastUpdateTime = 0;
     }
-    constructor(){
-        loadingAnimation_define_property(this, "chars", [
-            '⠋',
-            '⠙',
-            '⠹',
-            '⠸',
-            '⠼',
-            '⠴',
-            '⠦',
-            '⠧',
-            '⠇',
-            '⠏'
-        ]), loadingAnimation_define_property(this, "currentIndex", 0), loadingAnimation_define_property(this, "lastUpdateTime", 0), loadingAnimation_define_property(this, "interval", 100);
-    }
-}
-function progressBar_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
 }
 class ProgressBar {
+    prefix = 'transforming';
+    loadingAnimation = new LoadingAnimation();
     update({ current: originalCurrent, message = '' }) {
         let { columns: terminalWidth } = process.stdout, current = originalCurrent;
         originalCurrent >= 0.98 && (current = 1);
         let loadingChar = this.loadingAnimation.getCurrentChar(), messageWidth = terminalWidth - this.prefix.length - (1 === current ? 10 : 9);
         logUpdate(`${loadingChar} ${this.prefix} (${Math.floor(100 * current)}%) ${colors.dim(message.slice(0, messageWidth).padEnd(messageWidth, ' '))}`), 1 === current && clearLine();
     }
-    constructor(){
-        progressBar_define_property(this, "prefix", 'transforming'), progressBar_define_property(this, "loadingAnimation", new LoadingAnimation());
-    }
-}
-let 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;
-async function printFileSize({ root, stats }) {
-    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)}`));
 }
 function isLikelyFile(filePath) {
     return (filePath.split(sep).pop() || '').includes('.');
@@ -850,10 +833,7 @@ let getCompileTime = (stats)=>stats.toJson({
     }).time / 1000, sameCount = 0;
 async function compileDone(compiler, stats) {
     let root = compiler.options.context;
-    if (!stats.hasErrors()) if (utils_isProd()) global.__unpack_config.performance?.printFileSize && await printFileSize({
-        root,
-        stats
-    }), logger_logger.ready(colors.green(`built in ${prettyTime(getCompileTime(stats))}`));
+    if (!stats.hasErrors()) if (utils_isProd()) logger_logger.ready(colors.green(`built in ${prettyTime(getCompileTime(stats))}`));
     else {
         let fileInfo = function(changedFiles, removedFiles, root) {
             if (!changedFiles?.length && !removedFiles?.length) return null;
@@ -877,36 +857,59 @@ async function compileDone(compiler, stats) {
                 logger_logger.debug(`${colors.cyan(packageName)}: ${colors.yellow(count)} modules`);
             });
         }
-        isDebug() || logger_logger.clear(), console.log(colors.dim(getTime()), colors.cyan(`[${global.__unpack_caller_name}]`), 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)`) : '');
+        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)`) : '');
     }
 }
 let progress_PLUGIN_NAME = 'ProgressPlugin';
-class ProgressLiteRspackPlugin {
+class ProgressLitePlugin {
     apply(compiler) {
         compiler.hooks.afterDone.tap(progress_PLUGIN_NAME, async (stats)=>{
             await compileDone(compiler, stats);
         });
     }
 }
-class ProgressRspackPlugin extends rspack.ProgressPlugin {
-    apply(compiler) {
-        super.apply(compiler), compiler.hooks.afterDone.tap(progress_PLUGIN_NAME, async (stats)=>{
-            await compileDone(compiler, stats);
-        });
-    }
+class ProgressPlugin extends rspack.ProgressPlugin {
+    progressBar = new ProgressBar();
     constructor(){
-        var key, value;
         super((percentage, msg, ...args)=>{
             utils_isProd() && this.progressBar.update({
                 current: percentage,
                 message: `${msg} ${args.join(' ')}`
             });
-        }), key = "progressBar", value = new ProgressBar(), key in this ? Object.defineProperty(this, key, {
-            value: value,
-            enumerable: !0,
-            configurable: !0,
-            writable: !0
-        }) : this[key] = value;
+        });
+    }
+    apply(compiler) {
+        super.apply(compiler), compiler.hooks.afterDone.tap(progress_PLUGIN_NAME, async (stats)=>{
+            await compileDone(compiler, stats);
+        });
+    }
+}
+let registerHooks_PLUGIN_NAME = 'RegisterHooksPlugin';
+class RegisterHooksPlugin {
+    isFirstCompile = !0;
+    apply(compiler) {
+        compiler.hooks.beforeCompile.tapPromise(registerHooks_PLUGIN_NAME, async ()=>{
+            await applyPluginsByHook('buildStart', async (impl)=>{
+                await impl({
+                    compiler,
+                    isFirstCompile: this.isFirstCompile,
+                    isWatch: isWatch()
+                });
+            });
+        }), compiler.hooks.done.tapPromise(registerHooks_PLUGIN_NAME, async (stats)=>{
+            await applyPluginsByHook('buildEnd', async (impl)=>{
+                await impl({
+                    compiler,
+                    isFirstCompile: this.isFirstCompile,
+                    isWatch: isWatch(),
+                    stats
+                });
+            }), 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));
+        });
     }
 }
 async function applyTypeCheckConfig({ config, unpackConfig }) {
@@ -938,19 +941,25 @@ async function applyTypeCheckConfig({ config, unpackConfig }) {
         }
     })), config;
 }
+var bundler_config_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 async function getBundlerConfig(originalUnpackConfig) {
+    setCurrentUnpackConfig(originalUnpackConfig);
     let { plugins, bundlerConfig, ...rest } = originalUnpackConfig;
-    for (let plugin of getNormalizedPluginsByHook('config', plugins))rest = await plugin.config(rest, {
-        ...originalUnpackConfig._context,
-        mergeConfig: mergeConfig
+    await applyPluginsByHook('config', async (impl)=>{
+        rest = await impl(rest, {
+            ...originalUnpackConfig._context,
+            mergeConfig: mergeConfig
+        });
     });
     let unpackConfig = {
         ...rest,
         plugins,
         bundlerConfig
     };
-    global.__unpack_config = unpackConfig;
-    let tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTs = node_fs.existsSync(tsconfigPath), minifyOptions = isPlainObject(unpackConfig.build?.minify) ? unpackConfig.build?.minify : {}, ProgressPlugin = unpackConfig.build?.progressBar ? ProgressRspackPlugin : ProgressLiteRspackPlugin, { publicVars, filePaths: envFilePaths } = function({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
+    setCurrentUnpackConfig(unpackConfig), await applyPluginsByHook('configResolved', async (impl)=>{
+        await impl(unpackConfig);
+    });
+    let tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTs = node_fs.existsSync(tsconfigPath), minifyOptions = isPlainObject(unpackConfig.build?.minify) ? unpackConfig.build?.minify : {}, { publicVars, filePaths: envFilePaths } = function({ cwd = process.cwd(), mode = getNodeEnv(), prefixes = [
         'PUBLIC_'
     ], processEnv = process.env } = {}) {
         if ('local' === mode) throw Error(`${colors.yellow('local')} cannot be used as a value for env mode, because ${colors.yellow('.env.local')} represents a temporary local file. Please use another value.`);
@@ -1018,14 +1027,14 @@ async function getBundlerConfig(originalUnpackConfig) {
             }),
             crossOriginLoading: 'anonymous',
             pathinfo: !1,
-            publicPath: unpackConfig.build?.publicPath,
+            publicPath: unpackConfig.base,
             webassemblyModuleFilename: 'wasm/[contenthash:8].module.wasm',
             assetModuleFilename: 'assets/[name].[contenthash:8][ext]'
         },
         infrastructureLogging: {
             level: 'error'
         },
-        devtool: unpackConfig.build?.sourceMap,
+        devtool: unpackConfig.sourceMap,
         module: {
             rules: [
                 {
@@ -1055,22 +1064,6 @@ async function getBundlerConfig(originalUnpackConfig) {
                 ...publicVars,
                 ...unpackConfig.define
             }),
-            !unpackConfig.mpa && new rspack.HtmlRspackPlugin({
-                template: unpackConfig.html?.template || void 0,
-                templateContent: unpackConfig.html?.templateContent || (unpackConfig.html?.template ? void 0 : TEMPLATE_CONTENT),
-                templateParameters: {
-                    mountId: unpackConfig.html.mountId,
-                    title: isFunction(unpackConfig.html?.title) ? unpackConfig.html?.title({
-                        entryName: 'index'
-                    }) : unpackConfig.html?.title || '',
-                    headTag: unpackConfig.html?.headTag || '',
-                    ...unpackConfig.html?.templateParameters
-                },
-                minify: !1,
-                chunks: [
-                    'main'
-                ]
-            }),
             unpackConfig.performance?.removeMomentLocale && new rspack.IgnorePlugin({
                 resourceRegExp: /^\.\/locale$/,
                 contextRegExp: /moment$/
@@ -1078,7 +1071,8 @@ async function getBundlerConfig(originalUnpackConfig) {
             unpackConfig.build?.copy && new rspack.CopyRspackPlugin({
                 patterns: unpackConfig.build.copy
             }),
-            new ProgressPlugin()
+            new RegisterHooksPlugin(),
+            unpackConfig.build?.progressBar ? new ProgressPlugin() : new ProgressLitePlugin()
         ].filter(Boolean),
         externals: unpackConfig.externals,
         resolve: {
@@ -1119,7 +1113,7 @@ async function getBundlerConfig(originalUnpackConfig) {
         },
         optimization: {
             moduleIds: isDev() ? 'named' : 'deterministic',
-            minimize: !!unpackConfig.build?.minify,
+            minimize: !!unpackConfig.build?.minify && utils_isProd(),
             minimizer: [
                 new JsMinifyPlugin(mergeConfig({
                     compress: {
@@ -1139,8 +1133,23 @@ async function getBundlerConfig(originalUnpackConfig) {
         performance: {
             hints: !1
         }
-    };
-    for (let plugin of (config = (({ config, unpackConfig })=>{
+    }, transformPlugins = getNormalizedPluginsByHook('transform');
+    return transformPlugins.length && config.module.rules.push({
+        test: SCRIPT_REGEX,
+        enforce: 'pre',
+        exclude: /node_modules/,
+        use: [
+            {
+                loader: node_path.resolve(bundler_config_dirname, './transformLoader.js'),
+                options: {
+                    plugins: transformPlugins
+                }
+            }
+        ]
+    }), config = await applyHtmlConfig({
+        config,
+        unpackConfig
+    }), config = (({ config, unpackConfig })=>{
         let { chunkSplit } = unpackConfig.performance || {};
         if (chunkSplit?.strategy) {
             let forceSplittingGroups = {};
@@ -1304,7 +1313,7 @@ async function getBundlerConfig(originalUnpackConfig) {
                         }
                     },
                     isDev() && {
-                        loader: node_path.resolve(css_dirname, './typedCssModulesLoader.mjs'),
+                        loader: node_path.resolve(css_dirname, './typedCssModulesLoader.js'),
                         options: {
                             modules
                         }
@@ -1404,7 +1413,7 @@ async function getBundlerConfig(originalUnpackConfig) {
             unpackConfig
         }),
         unpackConfig
-    }), unpackConfig.build?.cache && (config = await applyCacheConfig({
+    }), unpackConfig.performance?.cache && (config = await applyCacheConfig({
         config,
         unpackConfig,
         envFilePaths
@@ -1454,12 +1463,13 @@ async function getBundlerConfig(originalUnpackConfig) {
     }({
         config,
         unpackConfig
-    })), getNormalizedPluginsByHook('bundlerConfig', unpackConfig.plugins)))config = await plugin.bundlerConfig(config, {
-        ...unpackConfig._context,
-        unpackConfig,
-        mergeConfig: mergeConfig
-    });
-    return unpackConfig.bundlerConfig && (config = isFunction(unpackConfig.bundlerConfig) ? await unpackConfig.bundlerConfig(config, {
+    })), await applyPluginsByHook('bundlerConfig', async (impl)=>{
+        config = await impl(config, {
+            ...unpackConfig._context,
+            unpackConfig,
+            mergeConfig: mergeConfig
+        });
+    }), unpackConfig.bundlerConfig && (config = isFunction(unpackConfig.bundlerConfig) ? await unpackConfig.bundlerConfig(config, {
         mergeConfig: mergeConfig
     }) : mergeConfig(config, unpackConfig.bundlerConfig)), config;
 }
@@ -1539,302 +1549,7 @@ function execAsync(command, options) {
         });
     });
 }
-var prebundleDeps_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-let SPECIAL_NO_ENTRY_DEPS = [
-    '@iconify-icons/material-symbols'
-], 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)}`, prebundleDeps = async ({ unpackConfig })=>{
-    var externals;
-    let existExternals, cacheDir, shouldTransformDeepImport = !1, count = {
-        total: 0,
-        bundled: 0
-    }, failedDeps = [], root = unpackConfig.root, CACHE_PATH = unpackConfig._context.cachePath, failedDepsCachePath = node_path.resolve(root, CACHE_PATH, 'failed-deps.json'), failedCache = node_fs.existsSync(failedDepsCachePath) ? JSON.parse(node_fs.readFileSync(failedDepsCachePath, '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(unpackConfig.dev?.prebundle) ? unpackConfig.dev.prebundle : {}, ignoreCSSDeps = userOptions.ignoreCSS || [], packageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'package.json'), 'utf-8')), excludeDeps = [
-        ...(externals = unpackConfig.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)=>{
-            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 packageJson = JSON.parse(node_fs.readFileSync(node_path.resolve(root, 'node_modules', pkgName, 'package.json'), 'utf-8')), version = packageJson.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;
-        })(packageJson);
-        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([
-        '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(root, CACHE_PATH, 'umd', 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
-                    },
-                    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: /\.(j|t)s$/,
-                                use: [
-                                    {
-                                        loader: 'builtin:swc-loader',
-                                        options: getSwcOptions({
-                                            tsx: !1
-                                        })
-                                    }
-                                ]
-                            },
-                            {
-                                test: /\.(j|t)sx$/,
-                                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'
-                                            ])
-                                        }
-                                    }
-                                ]
-                            }
-                        ]
-                    },
-                    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)));
-    cacheDir = node_path.dirname(failedDepsCachePath), node_fs.existsSync(cacheDir) || node_fs.mkdirSync(cacheDir, {
-        recursive: !0
-    }), node_fs.writeFileSync(failedDepsCachePath, JSON.stringify(failedCache, null, 2), 'utf-8');
-    let cachePath = node_path.resolve(root, CACHE_PATH, 'umd'), staticServer = node_http.createServer((req, res)=>{
-        if (res.setHeader('Access-Control-Allow-Origin', '*'), 'OPTIONS' === req.method) {
-            res.writeHead(204), res.end();
-            return;
-        }
-        let url = req.url || '';
-        if (url.startsWith("/umd/")) {
-            let relativePath = url.replace("/umd/", '');
-            if (relativePath.includes('..')) {
-                res.writeHead(403), res.end();
-                return;
-            }
-            let filePath = node_path.join(cachePath, relativePath);
-            if (node_fs.existsSync(filePath)) {
-                let stat = node_fs.statSync(filePath);
-                if (stat.isFile()) {
-                    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.writeHead(304), res.end();
-                        return;
-                    }
-                    res.writeHead(200), node_fs.createReadStream(filePath).pipe(res);
-                    return;
-                }
-            }
-        }
-        res.writeHead(404), res.end();
-    }), port = await getPort();
-    staticServer.listen(port), addRestartCleaner(()=>new Promise((resolve)=>staticServer.close(()=>resolve(void 0))));
-    let externals1 = {}, jsAssets = [], cssAssets = [], preJsAssets = [];
-    bundledDeps.filter(Boolean).forEach((dep)=>{
-        dep && (externals1[dep.name] = getExternalValue(dep.name), dep.assets.forEach((absPath)=>{
-            let relativePath = node_path.relative(cachePath, absPath), preDeps = [
-                'react',
-                'react-dom',
-                'react-router-dom'
-            ], serverPath = `//localhost:${port}/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 existingExternals = unpackConfig.externals ? Array.isArray(unpackConfig.externals) ? unpackConfig.externals : [
-        unpackConfig.externals
-    ] : [];
-    return unpackConfig.externals = [
-        externals1,
-        ...existingExternals
-    ], unpackConfig.plugins.push({
-        name: 'unpack:prebundle',
-        config: (config)=>{
-            let originalHeadTag = config.html?.headTag || '', sortedPreTags = preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path).map((item)=>`<script defer src="${item}"></script>`);
-            return set(config, [
-                'html',
-                'headTag'
-            ], `${sortedPreTags.join('')}${originalHeadTag}`), config;
-        },
-        bundlerConfig: (config)=>{
-            let PLUGIN_NAME = 'PluginInjectAssets';
-            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));
-                    });
-                }
-            }), shouldTransformDeepImport && config.module.rules.push({
-                test: /\.[jt]sx?$/,
-                exclude: /node_modules/,
-                use: [
-                    {
-                        loader: node_path.resolve(prebundleDeps_dirname, './transformDeepImportLoader.mjs'),
-                        options: {
-                            packages: SPECIAL_NO_ENTRY_DEPS
-                        }
-                    }
-                ]
-            }), config;
-        }
-    }), unpackConfig;
-};
-async function unpackDev(originalUnpackConfig) {
-    let unpackConfig = originalUnpackConfig;
-    unpackConfig.dev?.prebundle && (unpackConfig = await prebundleDeps({
-        unpackConfig
-    }));
+async function unpackDev(unpackConfig) {
     let compiler = rspack(await getBundlerConfig(unpackConfig)), port = await getPort(unpackConfig.server?.port), proxyConfig = unpackConfig.server?.proxy;
     isPlainObject(proxyConfig) && (proxyConfig = Object.entries(proxyConfig).map(([contextStr, target])=>{
         let baseConfig = {
@@ -1849,7 +1564,7 @@ async function unpackDev(originalUnpackConfig) {
             target
         };
     }));
-    let devServerOptions = {
+    let devPublicPath = normalizePublicPath(unpackConfig.base), devServerOptions = {
         hot: !0,
         port,
         open: !1,
@@ -1858,62 +1573,50 @@ async function unpackDev(originalUnpackConfig) {
         },
         proxy: proxyConfig,
         devMiddleware: {
+            publicPath: devPublicPath,
             writeToDisk: unpackConfig.dev?.writeToDisk
         }
-    };
-    devServerOptions.setupMiddlewares = (middlewares)=>(middlewares.unshift((req, _, next)=>{
-            req.headers.accept?.includes('html') && (req.url = '/index.html'), next();
-        }), middlewares.unshift(rspack.lazyCompilationMiddleware(compiler)), middlewares);
+    }, pluginMiddlewares = [];
+    await applyPluginsByHook('setupMiddlewares', async (impl)=>{
+        pluginMiddlewares = await impl(pluginMiddlewares);
+    }), devServerOptions.setupMiddlewares = (middlewares)=>(middlewares.unshift((req, _, next)=>{
+            let accept = req.headers.accept;
+            if ('string' == typeof accept && accept.includes('html')) {
+                let url = req.url || '/';
+                '/' === devPublicPath ? req.url = '/index.html' : (url === devPublicPath.slice(0, -1) || url.startsWith(devPublicPath)) && (req.url = `${devPublicPath}index.html`);
+            }
+            next();
+        }), middlewares.unshift(rspack.lazyCompilationMiddleware(compiler)), [
+            ...pluginMiddlewares,
+            ...middlewares
+        ]);
     let server = new RspackDevServer(devServerOptions, compiler);
-    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v3.7.8${unpackConfig.build?.cache ? ' ϟ' : ''}`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - global.__unpack_start_time))} ${colors.dim('ms')}\n`), printAddressUrls(port, unpackConfig.server?.host), addRestartCleaner(()=>server.stop(), ()=>new Promise((resolve)=>compiler.close(()=>resolve())));
-    let open = unpackConfig.server?.open, url = isString(open) ? open : `http://localhost:${port}`;
-    open && openBrowser(url), setupCliShortcuts({
-        openPage: async ()=>{
-            await openBrowser(url);
-        },
-        closeServer: async ()=>{
-            await cleanUpBeforeRestart(), process.exit(0);
-        },
-        printUrls: ()=>{
-            printAddressUrls(port, unpackConfig.server?.host);
-        },
-        restartServer: async ()=>{
-            logger_logger.clear(), await cleanUpBeforeRestart(), createUnpack({
-                cwd: currentDevUnpackConfig.root,
-                config: currentDevUnpackConfig
-            }).dev();
-        }
-    });
-}
-function printAddressUrls(port, host) {
-    let addressUrls = getAddressUrls({
-        port
-    }), colorPrefix = colors.brand('➜');
-    addressUrls.forEach((addr, index)=>{
-        let url;
-        if (!host && 0 !== index) {
-            1 === index && console.log(`  ${colors.dim(colorPrefix)}  ${colors.bold(colors.dim('Network:'))} ${colors.dim('use')} ${colors.bold('--host')} ${colors.dim('to expose')}`);
-            return;
-        }
-        console.log(`  ${colorPrefix}  ${colors.bold(addr.label)}${(url = addr.url, colors.cyan(url.replace(/:(\d+)\//, (_, port)=>`:${colors.bold(port)}/`)))}`);
-    });
+    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v3.8.1${unpackConfig.performance?.cache ? ' ϟ' : ''}`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
+        port,
+        host: unpackConfig.server?.host,
+        base: unpackConfig.base
+    }), addRestartCleaner(()=>server.stop(), ()=>new Promise((resolve)=>compiler.close(()=>resolve())));
+    let open = unpackConfig.server?.open, url = isString(open) ? open : `http://localhost:${port}${devPublicPath}`;
+    return open && openBrowser(url), {
+        port,
+        url
+    };
 }
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "3.7.8",
+        version: "3.8.1",
         cachePath: 'node_modules/.unpack'
-    };
-    global.__unpack_caller_name = callerName;
-    let resolveConfig = (mode)=>{
-        let isProd;
+    }, resolveConfig = (mode)=>{
+        let rootPath, outputPath, basePath, cachedTraceMap, fs, isValidMethodName, parseFrame, formatOriginalLocation, formatFullStack, resolveErrorLocationAndStack, shouldTransformDeepImport, preJsAssets, jsAssets, cssAssets, bundledDepsCachePath, deepImportPkgPattern, deepImportRegex, root;
         return {
             ...mergeConfig({
                 root: cwd,
+                base: '/',
+                sourceMap: 'production' !== mode && 'cheap-module-source-map',
                 build: {
                     outDir: 'dist',
-                    minify: isProd = 'production' === mode,
-                    sourceMap: !isProd && 'cheap-module-source-map',
+                    minify: !0,
                     filenameHash: !0,
                     target: 'es2022'
                 },
@@ -1932,11 +1635,616 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     chunkSplit: {
                         strategy: 'single-vendor'
                     },
-                    printFileSize: !0
+                    printFileSize: !0,
+                    cache: !0
                 },
                 typeCheck: !0,
                 envPrefix: [
                     'PUBLIC_'
+                ],
+                plugins: [
+                    (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));
+                        }
+                        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;
+                        }
+                    }, 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);
+                            }
+                            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);
+                            }
+                        }
+                        return srcLines.length > 0 ? srcLines.join('') : 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 && 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>
+;(() => {
+  if (typeof window === 'undefined' || typeof console === 'undefined') return
+  const endpoint = '${BROWSER_LOGS_ENDPOINT}'
+  const levels = ['error', 'warn', 'debug']
+  const send = (level, args) => {
+    try {
+      const argsList = Array.prototype.slice.call(args)
+      if (level === 'debug') {
+        const stackHolder = new Error()
+        stackHolder.name = ''
+        stackHolder.message = ''
+        argsList.push(stackHolder)
+      }
+      const payload = {
+        level,
+        time: new Date().toLocaleTimeString(),
+        args: argsList.map((item) => {
+          try {
+            if (item instanceof Error) {
+              const name = item.name || ''
+              const msg = item.message ? ': ' + item.message : ''
+              return {
+                type: 'error',
+                message: name + msg,
+                stack: item.stack,
+              }
+            }
+            if (item === null) {
+              return { type: 'null', message: 'null' }
+            }
+            const t = typeof item
+            if (['string', 'number', 'boolean'].includes(t)) {
+              return { type: t, message: item }
+            }
+            if (['undefined', 'function', 'symbol', 'bigint'].includes(t)) {
+              return { type: t, message: String(item) }
+            }
+            return { type: 'object', message: JSON.stringify(item) }
+          } catch (e) {
+            return { type: 'unknown', message: String(item) }
+          }
+        }),
+      }
+      const body = JSON.stringify(payload)
+      if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+        navigator.sendBeacon(endpoint, body)
+      } else if (typeof fetch === 'function') {
+        fetch(endpoint, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body,
+          keepalive: true,
+        }).catch(() => {})
+      }
+    } catch (e) {}
+  }
+  levels.forEach((level) => {
+    const original = console[level]
+    if (!original || typeof original !== 'function') return
+    console[level] = (...args) => {
+      try {
+        original.apply(console, args)
+      } finally {
+        send(level, args)
+      }
+    }
+  })
+  window.addEventListener('error', (event) => {
+      send('error', [event.error || event.message])
+  })
+  window.addEventListener('unhandledrejection', (event) => {
+      send('error', [event.reason])
+  })
+})()
+</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}`;
+                                                }
+                                                switch(item.type){
+                                                    case 'string':
+                                                        return ((message)=>{
+                                                            let trimmed = message.trim();
+                                                            if (!trimmed) return !0;
+                                                            let normalizedFirstLine = (trimmed.split('\n', 1)[0]?.trim() || '').replace(/`/g, '');
+                                                            return /^at\s+/.test(normalizedFirstLine);
+                                                        })(item.message) ? '' : item.message;
+                                                    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;
+                                                    }
+                                                    let next = template[i + 1];
+                                                    if ('%' === next) {
+                                                        cleanedTemplate += '%%', i++;
+                                                        continue;
+                                                    }
+                                                    if ('c' === next) {
+                                                        rest.length > 0 && rest.shift(), i++;
+                                                        continue;
+                                                    }
+                                                    cleanedTemplate += `%${next}`, i++;
+                                                }
+                                                return [
+                                                    format(cleanedTemplate, ...rest)
+                                                ];
+                                            })(formattedArgs), prefix = colors.dim(`[browser ${time}]`);
+                                            switch(level){
+                                                case 'error':
+                                                    logger_logger.error(`${prefix} ${outputArgs.join(' ')}`);
+                                                    break;
+                                                case 'warn':
+                                                    logger_logger.warn(`${prefix} ${outputArgs.join(' ')}`);
+                                                    break;
+                                                case 'debug':
+                                                    logger_logger.info(prefix, ...outputArgs);
+                                            }
+                                        } catch (e) {
+                                            logger_logger.error('Failed to parse browser log payload', e);
+                                        } finally{
+                                            res.statusCode = 204, res.end();
+                                        }
+                                    });
+                                },
+                                ...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'), {
+                        name: 'unpack:prebundle',
+                        apply: (config, { command })=>'dev' === command && !!config.dev?.prebundle,
+                        config: async (config, context)=>{
+                            var externals;
+                            let existExternals, cacheDir, 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)=>{
+                                    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
+                                        };
+                                    }
+                                    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([
+                                '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'
+                                                        }
+                                                    }
+                                                }
+                                            }), compiler = rspack({
+                                            entry: {
+                                                index: entry
+                                            },
+                                            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: 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'
+                                                                    ])
+                                                                }
+                                                            }
+                                                        ]
+                                                    }
+                                                ]
+                                            },
+                                            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)));
+                            cacheDir = node_path.dirname(failedDepsJsonPath), node_fs.existsSync(cacheDir) || node_fs.mkdirSync(cacheDir, {
+                                recursive: !0
+                            }), node_fs.writeFileSync(failedDepsJsonPath, JSON.stringify(failedCache, null, 2), 'utf-8');
+                            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 existingExternals = config.externals ? Array.isArray(config.externals) ? config.externals : [
+                                config.externals
+                            ] : [];
+                            return config.externals = [
+                                externals1,
+                                ...existingExternals
+                            ], config;
+                        },
+                        transform: (code, id)=>shouldTransformDeepImport && JSX_REGEX.test(id) && code.includes('import') && 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,
+                        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 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, 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)}`));
+                        }
+                    })
                 ]
             }, userConfig),
             _context
@@ -1947,14 +2255,14 @@ 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} v3.7.8${config.build?.cache ? ' ϟ' : ''}`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v3.8.1${config.performance?.cache ? ' ϟ' : ''}`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
-            global.__unpack_start_time = performance.now();
+            setUnpackStartTime(performance.now());
             let mode = 'development';
             setNodeEnv(mode), setDevServer(!0);
             let config = resolveConfig(mode);
-            await unpackDev(config);
+            return await unpackDev(config);
         },
         clean: ()=>{
             let root = userConfig.root || cwd, relativeDir = _context.cachePath, absDir = node_path.resolve(root, relativeDir);
@@ -1975,5 +2283,5 @@ async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
         ...options
     });
 }
-var __webpack_exports__CSS_NAMED_EXPORT = !1;
-export { CSS_MODULES_LOCAL_IDENT_NAME, CSS_MODULES_REGEX, DEFAULT_DEV_HOST, DEV_DEFAULT_FILENAME, EXPORT_LOCALS_CONVENTION, logger_LogColor as LogColor, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, TEMPLATE_CONTENT, addRestartCleaner, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, currentDevUnpackConfig, debounce, defineConfig, esVersionToBrowserslist, findExists, getAddressUrls, getCompiledPkgPath, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUserDepPath, getUserDepVersion, isBoolean, isCSSModules, isDebug, isDev, utils_isDevServer as isDevServer, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, utils_isProd as isProd, isRegExp, isString, isUndefined, isWatch, isWin, launchEditor, loadConfig, logUpdate, logger_logger as logger, mergeConfig, pLimit, pathExists, pathToExportIdentifier, prettyTime, removeDir, resolveConfigPath, rspack, set, setCurrentDevUnpackConfig, setDevServer, setNodeEnv, setupCliShortcuts, trackPerformance, __webpack_exports__CSS_NAMED_EXPORT as CSS_NAMED_EXPORT };
+var src_CSS_NAMED_EXPORT = !1;
+export { CSS_MODULES_LOCAL_IDENT_NAME, CSS_MODULES_REGEX, DEFAULT_DEV_HOST, DEV_DEFAULT_FILENAME, EXPORT_LOCALS_CONVENTION, JSX_REGEX, JS_REGEX, 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, isCSSModules, 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, set, setCurrentUnpackConfig, setDevServer, setNodeEnv, setUnpackStartTime, setupCliShortcuts, src_CSS_NAMED_EXPORT as CSS_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd };