@unpackjs/core 2.4.1 → 2.4.2

package/dist/index.cjs

@@ -1,217 +1,2049 @@
 "use strict";
+let __rslib_import_meta_url__ = 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 var __webpack_modules__ = {
-    "./colors": function(module) {
-        module.exports = require("./colors.cjs");
+    "compiled/webpack-bundle-analyzer": function(module) {
+        module.exports = require("../compiled/webpack-bundle-analyzer/index.js");
     },
-    "./config": function(module) {
-        module.exports = require("./config.cjs");
-    },
-    "./constants": function(module) {
-        module.exports = require("./constants.cjs");
-    },
-    "./createUnpack": function(module) {
-        module.exports = require("./createUnpack.cjs");
-    },
-    "./fs": function(module) {
-        module.exports = require("./fs.cjs");
-    },
-    "./global": function(module) {
-        module.exports = require("./global.cjs");
-    },
-    "./logger": function(module) {
-        module.exports = require("./logger.cjs");
-    },
-    "src/types/index": function(module) {
-        module.exports = require("./types/index.cjs");
-    },
-    "./utils": function(module) {
-        module.exports = require("./utils.cjs");
-    },
-    "./watchFiles": function(module) {
-        module.exports = require("./watchFiles.cjs");
-    },
-    "@rspack/core": function(module) {
-        module.exports = require("@rspack/core");
-    },
-    "html-webpack-plugin": function(module) {
-        module.exports = require("html-webpack-plugin");
-    },
-    webpack: function(module) {
-        module.exports = require("webpack");
+    "compiled/webpack-merge": function(module) {
+        module.exports = require("../compiled/webpack-merge/index.js");
     }
-};
-var __webpack_module_cache__ = {};
+}, __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: {}
     };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
 }
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
+__webpack_require__.n = (module)=>{
+    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
+    return __webpack_require__.d(getter, {
+        a: getter
+    }), getter;
+}, __webpack_require__.d = (exports1, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports1)=>{
+    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports1, '__esModule', {
+        value: !0
+    });
+};
+var __webpack_exports__ = {};
+for(var __webpack_i__ in (()=>{
+    __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
+        setValueByPath: ()=>setValueByPath,
+        TEMPLATE_CONTENT: ()=>TEMPLATE_CONTENT,
+        removeDir: ()=>removeDir,
+        getAddressUrls: ()=>getAddressUrls,
+        isDevServer: ()=>utils_isDevServer,
+        restartCleaners: ()=>restartCleaners,
+        isFileExists: ()=>isFileExists,
+        getNodeEnv: ()=>getNodeEnv,
+        isFunction: ()=>isFunction,
+        THREAD_OPTIONS: ()=>THREAD_OPTIONS,
+        debounce: ()=>debounce,
+        isDev: ()=>isDev,
+        isWatch: ()=>isWatch,
+        isNodeVersionAtLeast: ()=>isNodeVersionAtLeast,
+        setNodeEnv: ()=>setNodeEnv,
+        DEFAULT_LIGHTNINGCSS_TARGET: ()=>DEFAULT_LIGHTNINGCSS_TARGET,
+        getCompiledPkgPath: ()=>getCompiledPkgPath,
+        LogColor: ()=>logger_LogColor,
+        isDebug: ()=>isDebug,
+        CSS_MODULES_REGEX: ()=>CSS_MODULES_REGEX,
+        loadConfig: ()=>loadConfig,
+        PROD_DEFAULT_FILENAME: ()=>PROD_DEFAULT_FILENAME,
+        prettyTime: ()=>prettyTime,
+        mergeConfig: ()=>mergeConfig,
+        isString: ()=>isString,
+        getPathInJs: ()=>getPathInJs,
+        isFileSync: ()=>isFileSync,
+        clearLine: ()=>clearLine,
+        TEMP_DIR: ()=>TEMP_DIR,
+        EXPORT_LOCALS_CONVENTION: ()=>EXPORT_LOCALS_CONVENTION,
+        isProd: ()=>isProd,
+        isBoolean: ()=>isBoolean,
+        DEFAULT_ES_TARGET: ()=>DEFAULT_ES_TARGET,
+        createChokidar: ()=>createChokidar,
+        CSS_MODULES_LOCAL_IDENT_NAME: ()=>CSS_MODULES_LOCAL_IDENT_NAME,
+        setDevServer: ()=>setDevServer,
+        findExists: ()=>findExists,
+        getUserDepVersion: ()=>getUserDepVersion,
+        DEFAULT_BROWSERSLIST: ()=>DEFAULT_BROWSERSLIST,
+        NODE_MODULES_REGEX: ()=>NODE_MODULES_REGEX,
+        webpack: ()=>external_webpack_default(),
+        getTime: ()=>getTime,
+        getValueByPath: ()=>getValueByPath,
+        getIpv4Interfaces: ()=>getIpv4Interfaces,
+        isCI: ()=>isCI,
+        colors: ()=>colors,
+        isEmptyDir: ()=>isEmptyDir,
+        logger: ()=>logger_logger,
+        resolveConfigPath: ()=>resolveConfigPath,
+        DEFAULT_DEV_HOST: ()=>DEFAULT_DEV_HOST,
+        isRegExp: ()=>isRegExp,
+        isWin: ()=>isWin,
+        pathExists: ()=>pathExists,
+        isPlainObject: ()=>isPlainObject,
+        CSS_NAMED_EXPORT: ()=>CSS_NAMED_EXPORT,
+        DEV_DEFAULT_FILENAME: ()=>DEV_DEFAULT_FILENAME,
+        isUndefined: ()=>isUndefined,
+        defineConfig: ()=>defineConfig,
+        logUpdate: ()=>logUpdate,
+        isObject: ()=>isObject,
+        trackPerformance: ()=>trackPerformance,
+        createUnpack: ()=>createUnpack,
+        getPort: ()=>getPort,
+        HtmlWebpackPlugin: ()=>external_html_webpack_plugin_default(),
+        getUserDepPath: ()=>getUserDepPath,
+        isCSSModules: ()=>isCSSModules,
+        rspack: ()=>core_namespaceObject.rspack
+    });
+    let core_namespaceObject = require("@rspack/core"), external_html_webpack_plugin_namespaceObject = require("html-webpack-plugin");
+    var external_html_webpack_plugin_default = __webpack_require__.n(external_html_webpack_plugin_namespaceObject);
+    let external_webpack_namespaceObject = require("webpack");
+    var external_webpack_default = __webpack_require__.n(external_webpack_namespaceObject);
+    let external_picocolors_namespaceObject = require("picocolors"), colors = {
+        ...__webpack_require__.n(external_picocolors_namespaceObject)(),
+        rainbow: (input)=>{
+            let isWord = (char)=>!/[\s\n]/.test(char), chars = [
+                ...input
+            ], steps = chars.filter(isWord).length, r = 97, g = 193, b = 198, rStep = -49 / steps, gStep = -81 / steps, bStep = 0 / steps, output = '';
+            for (let char of chars)isWord(char) && (r += rStep, g += gStep, b += bStep), output += `\x1b[38;2;${Math.round(r)};${Math.round(g)};${Math.round(b)}m${char}\x1b[39m`;
+            return output;
+        }
+    }, external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_default = __webpack_require__.n(external_node_fs_namespaceObject);
+    let external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = __webpack_require__.n(external_node_path_namespaceObject);
+    let external_node_url_namespaceObject = require("node:url"), external_jiti_namespaceObject = require("jiti"), external_node_readline_namespaceObject = require("node:readline");
+    var external_node_readline_default = __webpack_require__.n(external_node_readline_namespaceObject), logger_LogColor = function(LogColor) {
+        return LogColor.error = "red", LogColor.warn = "yellow", LogColor.info = "cyan", LogColor.ready = "green", LogColor.event = "magenta", LogColor.wait = "blue", LogColor.debug = "dim", LogColor;
+    }({});
+    let external_node_net_namespaceObject = require("node:net");
+    var external_node_net_default = __webpack_require__.n(external_node_net_namespaceObject);
+    let external_node_os_namespaceObject = require("node:os");
+    var external_node_os_default = __webpack_require__.n(external_node_os_namespaceObject);
+    let external_portfinder_namespaceObject = require("portfinder");
+    var external_portfinder_default = __webpack_require__.n(external_portfinder_namespaceObject);
+    let external_lightningcss_namespaceObject = require("lightningcss"), 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',
+        css: 'css/[name].css',
+        cssAsync: 'css/async/[name].css'
+    }, PROD_DEFAULT_FILENAME = {
+        js: 'js/[name].[contenthash:8].js',
+        jsAsync: 'js/async/[name].[contenthash:8].js',
+        css: 'css/[name].[contenthash:8].css',
+        cssAsync: 'css/async/[name].[contenthash:8].css'
+    }, EXPORT_LOCALS_CONVENTION = 'camel-case-only', TEMP_DIR = 'node_modules/.unpack', NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/, CSS_NAMED_EXPORT = !1, THREAD_OPTIONS = {
+        workers: 2
+    }, DEFAULT_DEV_HOST = '0.0.0.0', DEFAULT_BROWSERSLIST = [
+        'chrome >= 107',
+        'edge >= 107',
+        'firefox >= 104',
+        'safari >= 16'
+    ], DEFAULT_ES_TARGET = 'es2022', DEFAULT_LIGHTNINGCSS_TARGET = (0, external_lightningcss_namespaceObject.browserslistToTargets)(DEFAULT_BROWSERSLIST.map((item)=>item.replace(' >= ', ' '))), 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>`, { merge } = __webpack_require__("compiled/webpack-merge"), getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
+        process.env.NODE_ENV = env;
+    }, setDevServer = (isDevServer)=>{
+        process.env.DEV_SERVER = isDevServer ? 'true' : 'false';
+    }, isDev = ()=>'development' === getNodeEnv(), utils_isDevServer = ()=>'true' === process.env.DEV_SERVER, isWatch = ()=>isDev() && !utils_isDevServer(), isProd = ()=>'production' === getNodeEnv(), isWin = ()=>'win32' === process.platform, isString = (str)=>'string' == typeof str, isBoolean = (bool)=>'boolean' == typeof bool, isUndefined = (obj)=>void 0 === obj, isFunction = (func)=>'function' == typeof func, isObject = (obj)=>null !== obj && 'object' == typeof obj, isPlainObject = (obj)=>isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj), isRegExp = (obj)=>'[object RegExp]' === Object.prototype.toString.call(obj), prettyTime = (seconds)=>{
+        let toFixed = (num, len)=>{
+            let factor = 10 ** len;
+            return Math.floor(num * factor) / factor;
+        };
+        return seconds < 1 ? `${toFixed(1000 * seconds, 0)}ms` : seconds < 60 ? `${toFixed(seconds, 2)}s` : `${toFixed(seconds / 60, 2)}m`;
+    }, getValueByPath = (target, pathArray, defaultValue)=>{
+        let current = target;
+        for(let i = 0; i < pathArray.length - 1; i++){
+            let currKey = pathArray[i];
+            current[currKey] && 'object' == typeof current[currKey] || (current[currKey] = 'string' == typeof pathArray[i + 1] ? {} : []), current = current[currKey];
+        }
+        let lastKey = pathArray.at(-1);
+        return void 0 === current[lastKey] && (current[lastKey] = defaultValue), current[lastKey];
+    }, setValueByPath = (target, pathArray, value)=>{
+        let current = target;
+        for(let i = 0; i < pathArray.length - 1; i++){
+            let currKey = pathArray[i];
+            current[currKey] && 'object' == typeof current[currKey] || (current[currKey] = 'string' == typeof pathArray[i + 1] ? {} : []), current = current[currKey];
+        }
+        current[pathArray.at(-1)] = value;
+    }, getPort = (startPort = 45678)=>new Promise((resolve)=>{
+            external_portfinder_default().getPort({
+                port: startPort
+            }, (_, port)=>{
+                resolve(port);
+            });
+        }), getCompiledPkgPath = (packageName)=>external_node_path_default().join(__dirname, '../compiled', packageName), getUserDepPath = (root, deps)=>{
+        for (let dep of Array.isArray(deps) ? deps : [
+            deps
+        ]){
+            let absPath = external_node_path_default().resolve(root, 'node_modules', dep);
+            if (external_node_fs_default().existsSync(absPath)) return absPath;
+        }
     };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
+    function getTime() {
+        let now = new Date(), hours = String(now.getHours()).padStart(2, '0'), minutes = String(now.getMinutes()).padStart(2, '0'), seconds = String(now.getSeconds()).padStart(2, '0');
+        return `${hours}:${minutes}:${seconds}`;
+    }
+    let debounce = (fn, delay)=>{
+        let timer = null;
+        return (...args)=>{
+            clearTimeout(timer), timer = setTimeout(()=>{
+                fn(...args);
+            }, delay);
+        };
+    }, getIpv4Interfaces = ()=>{
+        let interfaces = external_node_os_default().networkInterfaces(), ipv4Interfaces = new Map();
+        for (let key of Object.keys(interfaces))for (let detail of interfaces[key]){
+            let familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+            detail.family !== familyV4Value || ipv4Interfaces.has(detail.address) || ipv4Interfaces.set(detail.address, detail);
+        }
+        return Array.from(ipv4Interfaces.values());
+    }, isLoopbackHost = (host)=>[
+            'localhost',
+            '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 })=>{
+        if (host && host !== DEFAULT_DEV_HOST) return [
+            {
+                label: isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+                url: concatUrl({
+                    port,
+                    host: ((host)=>external_node_net_default().isIPv6(host) ? '::' === host ? '[::1]' : `[${host}]` : host)(host),
+                    protocol
+                })
+            }
+        ];
+        let ipv4Interfaces = getIpv4Interfaces(), addressUrls = [], hasLocalUrl = !1;
+        for (let detail of ipv4Interfaces)if (isLoopbackHost(detail.address) || detail.internal) {
+            if (hasLocalUrl) continue;
+            addressUrls.push({
+                label: LOCAL_LABEL,
+                url: concatUrl({
+                    host: 'localhost',
+                    port,
+                    protocol
+                })
+            }), hasLocalUrl = !0;
+        } else addressUrls.push({
+            label: NETWORK_LABEL,
+            url: concatUrl({
+                host: detail.address,
+                port,
+                protocol
+            })
         });
+        return addressUrls;
+    }, trackPerformance = (msg)=>{
+        let k = '__unpack_last_track_time';
+        if (!global[k]) {
+            global[k] = performance.now();
+            return;
+        }
+        msg && logger_logger.wait(`${msg} ${colors.dim('for')} ${colors.yellow(`${(performance.now() - global[k]).toFixed(2)}ms`)}`), global[k] = performance.now();
+    }, getPathInJs = (absPath)=>JSON.stringify(absPath).slice(1, -1), mergeConfig = merge, getUserDepVersion = (root, dep)=>{
+        let depPath = getUserDepPath(root, dep);
+        if (depPath) return JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().resolve(depPath, 'package.json'), 'utf-8')).version;
+    }, clearLine = ()=>{
+        process.stdout.isTTY && (process.stdout.clearLine(0), process.stdout.cursorTo(0));
+    }, logUpdate = (output)=>{
+        clearLine(), process.stdout.write(output);
+    }, isDebug = ()=>'unpack' === process.env.DEBUG, isCI = ()=>!!process.env.CI;
+    function isNodeVersionAtLeast(major, minor) {
+        let [currMajor, currMinor] = process.versions.node.split('.').map(Number);
+        return currMajor > major || currMajor === major && currMinor >= minor;
+    }
+    let isCSSModules = ({ resourcePath, modules })=>{
+        if (!1 === modules) return !1;
+        isPlainObject(modules) || (modules = {});
+        let auto = modules.auto;
+        return !1 !== auto && (isRegExp(auto) ? auto.test(resourcePath) : isFunction(auto) ? auto(resourcePath) : CSS_MODULES_REGEX.test(resourcePath));
+    }, logger_prefixes = {
+        wait: "\u25CB",
+        error: "\u2A2F",
+        warn: "\u26A0",
+        info: "\u2139",
+        ready: "\u2713",
+        event: "\xbb",
+        debug: "\u279C"
+    }, logger_logger = (()=>{
+        let logger = {
+            clear: ()=>{
+                let repeatCount = process.stdout.rows - 2;
+                console.log(repeatCount > 0 ? '\n'.repeat(repeatCount) : ''), external_node_readline_default().cursorTo(process.stdout, 0, 0), external_node_readline_default().clearScreenDown(process.stdout);
+            },
+            greet: (msg)=>{
+                let { npm_execpath, npm_lifecycle_event } = process.env;
+                (!npm_execpath || 'npx' === npm_lifecycle_event || npm_execpath.includes('npx-cli') || npm_execpath.includes('.bun') || npm_execpath.includes('yarn')) && console.log(), console.log(msg);
+            }
+        };
+        return Object.keys(logger_prefixes).forEach((type)=>{
+            logger[type] = (message, ...args)=>{
+                ((type, message, ...args)=>{
+                    let label = colors[logger_LogColor[type]](logger_prefixes[type]), text = '';
+                    switch(type){
+                        case 'error':
+                            if (message instanceof Error) if (message.stack) {
+                                let [name, ...rest] = message.stack.split('\n');
+                                name.startsWith('Error: ') && (name = name.slice(7), rest = rest.map((line)=>line.slice(2))), text = `${colors.red(name)}\n${colors.dim(rest.join('\n'))}`;
+                            } else text = colors.red(message.message);
+                            else text = colors.red(message);
+                            break;
+                        case 'warn':
+                            text = colors.yellow(message);
+                            break;
+                        case 'debug':
+                            text = `${colors.dim((()=>{
+                                let now = new Date(), hours = now.getHours().toString().padStart(2, '0'), minutes = now.getMinutes().toString().padStart(2, '0'), seconds = now.getSeconds().toString().padStart(2, '0');
+                                return `${hours}:${minutes}:${seconds}`;
+                            })())} ${colors.magenta('debug')} ${message}`;
+                            break;
+                        default:
+                            text = message;
+                    }
+                    ('debug' !== type || isDebug()) && console.log(`${label} ${text}`, ...args);
+                })(type, message, ...args);
+            };
+        }), logger;
+    })();
+    async function loadConfig({ cliOptions, command }) {
+        'build' === command ? setNodeEnv((null == cliOptions ? void 0 : cliOptions.watch) ? 'development' : 'production') : (setNodeEnv('development'), setDevServer(!0));
+        let root = (null == cliOptions ? void 0 : cliOptions.root) ? external_node_path_default().resolve(cliOptions.root) : process.cwd(), configFilePath = resolveConfigPath(root, null == cliOptions ? void 0 : cliOptions.config), configExport = {};
+        if (configFilePath) {
+            if (isNodeVersionAtLeast(23, 6) || /\.(?:js|mjs|cjs)$/.test(configFilePath)) {
+                logger_logger.debug('Loading config file with native loader:', colors.dim(configFilePath));
+                try {
+                    let configFileURL = (0, external_node_url_namespaceObject.pathToFileURL)(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
+                    configExport = exportModule.default ? exportModule.default : exportModule;
+                } catch (err) {
+                    throw logger_logger.error(`Failed to load config file with native loader: ${colors.dim(configFilePath)}`), err;
+                }
+            } else {
+                logger_logger.debug('Loading config file with jiti:', colors.dim(configFilePath));
+                try {
+                    let jiti = (0, external_jiti_namespaceObject.createJiti)(__filename, {
+                        moduleCache: !1,
+                        interopDefault: !0,
+                        nativeModules: [
+                            '@rspack/core',
+                            "typescript"
+                        ]
+                    });
+                    configExport = await jiti.import(configFilePath, {
+                        default: !0
+                    });
+                } catch (err) {
+                    throw logger_logger.error(`Failed to load config file with jiti: ${colors.dim(configFilePath)}`), err;
+                }
+            }
+            if ('function' == typeof configExport) {
+                let params = {
+                    env: getNodeEnv(),
+                    command: process.argv[2]
+                };
+                if (void 0 === (configExport = await configExport(params))) throw Error('Unpack config function must return a config object.');
+            }
+        }
+        return (null == cliOptions ? void 0 : cliOptions.port) && setValueByPath(configExport, [
+            'server',
+            'port'
+        ], cliOptions.port), (null == cliOptions ? void 0 : cliOptions.open) && setValueByPath(configExport, [
+            'server',
+            'open'
+        ], cliOptions.open), (null == cliOptions ? void 0 : cliOptions.analyze) && setValueByPath(configExport, [
+            'performance',
+            'bundleAnalyze'
+        ], cliOptions.analyze), (null == cliOptions ? void 0 : cliOptions.root) && setValueByPath(configExport, [
+            'root'
+        ], root), configExport;
+    }
+    function defineConfig(config) {
+        return config;
+    }
+    function resolveConfigPath(root, customConfig) {
+        if (customConfig) {
+            let customConfigPath = (0, external_node_path_namespaceObject.isAbsolute)(customConfig) ? customConfig : (0, external_node_path_namespaceObject.join)(root, customConfig);
+            if (external_node_fs_default().existsSync(customConfigPath)) return customConfigPath;
+            logger_logger.warn(`could not find config file: ${customConfigPath}`);
+        }
+        for (let file of [
+            'unpack.config.ts',
+            'unpack.config.js',
+            'unpack.config.mjs',
+            'unpack.config.cjs',
+            'unpack.config.mts',
+            'unpack.config.cts'
+        ]){
+            let configFile = (0, external_node_path_namespaceObject.join)(root, file);
+            if (external_node_fs_default().existsSync(configFile)) return configFile;
+        }
+        return null;
+    }
+    function getNormalizedPluginsByHook(hook, plugins) {
+        let pluginMap = new Map();
+        return null == plugins || plugins.forEach((plugin)=>{
+            plugin[hook] && pluginMap.set(plugin.name, plugin);
+        }), Array.from(pluginMap.values());
+    }
+    let external_copy_webpack_plugin_namespaceObject = require("copy-webpack-plugin");
+    var external_copy_webpack_plugin_default = __webpack_require__.n(external_copy_webpack_plugin_namespaceObject);
+    let external_json5_namespaceObject = require("json5");
+    var external_json5_default = __webpack_require__.n(external_json5_namespaceObject);
+    let external_dotenv_expand_namespaceObject = require("dotenv-expand"), isFileSync = (filePath)=>{
+        try {
+            var _fs_statSync;
+            return null == (_fs_statSync = external_node_fs_default().statSync(filePath, {
+                throwIfNoEntry: !1
+            })) ? void 0 : _fs_statSync.isFile();
+        } catch (_) {
+            return !1;
+        }
+    };
+    function isEmptyDir(path) {
+        let files = external_node_fs_default().readdirSync(path);
+        return 0 === files.length || 1 === files.length && '.git' === files[0];
+    }
+    let findExists = (files)=>{
+        for (let file of files)if (isFileSync(file)) return file;
+        return !1;
     };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
+    async function pathExists(path) {
+        return external_node_fs_default().promises.access(path).then(()=>!0).catch(()=>!1);
+    }
+    async function isFileExists(file) {
+        return external_node_fs_default().promises.access(file, external_node_fs_default().constants.F_OK).then(()=>!0).catch(()=>!1);
+    }
+    let removeDir = (dir)=>{
+        external_node_fs_default().rmSync(dir, {
+            recursive: !0,
+            force: !0
         });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
+    }, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm, external_ts_checker_rspack_plugin_namespaceObject = require("ts-checker-rspack-plugin");
+    async function getBuildDependencies(root, userBuildDependencies, envFilePaths) {
+        let rootPackageJson = external_node_path_default().join(root, 'package.json'), browserslistConfig = external_node_path_default().join(root, '.browserslistrc'), tsconfigPath = external_node_path_default().join(root, 'tsconfig.json'), buildDependencies = {};
+        await isFileExists(rootPackageJson) && (buildDependencies.packageJson = [
+            rootPackageJson
+        ]), await isFileExists(tsconfigPath) && (buildDependencies.tsconfig = [
+            tsconfigPath
+        ]), buildDependencies.unpackConfig = [
+            resolveConfigPath(root)
+        ], await isFileExists(browserslistConfig) && (buildDependencies.browserslistrc = [
+            browserslistConfig
+        ]);
+        let tailwindConfig = findExists([
+            'ts',
+            'js',
+            'cjs',
+            'mjs'
+        ].map((ext)=>external_node_path_default().join(root, `tailwind.config.${ext}`)));
+        return tailwindConfig && (buildDependencies.tailwindcss = [
+            tailwindConfig
+        ]), envFilePaths && envFilePaths.length > 0 && (buildDependencies.envFiles = envFilePaths), {
+            ...buildDependencies,
+            userBuildDependencies
+        };
+    }
+    async function applyCacheConfig({ config, unpackConfig, envFilePaths }) {
+        var _unpackConfig_build, _unpackConfig_dev;
+        if (!(null == (_unpackConfig_build = unpackConfig.build) ? void 0 : _unpackConfig_build.cache) || utils_isDevServer() && (null == (_unpackConfig_dev = unpackConfig.dev) ? void 0 : _unpackConfig_dev.lazyCompilation)) return config;
+        let cacheConfig = isPlainObject(unpackConfig.build.cache) ? unpackConfig.build.cache : {}, isRspack = 'rspack' === unpackConfig.bundler, buildDependencies = await getBuildDependencies(unpackConfig.root, cacheConfig.buildDependencies || [], envFilePaths), cacheDirectory = cacheConfig.cacheDirectory;
+        return cacheDirectory && (cacheDirectory = external_node_path_default().isAbsolute(cacheDirectory) ? cacheDirectory : external_node_path_default().join(unpackConfig.root, cacheDirectory)), logger_logger.info('persistent cache enabled'), config = isRspack ? mergeConfig(config, {
+            cache: !0,
+            experiments: {
+                cache: {
+                    type: 'persistent',
+                    buildDependencies: Object.values(buildDependencies).flat(),
+                    storage: {
+                        type: 'filesystem',
+                        directory: cacheDirectory
+                    }
+                }
+            }
+        }) : mergeConfig(config, {
+            cache: {
+                type: 'filesystem',
+                buildDependencies,
+                cacheDirectory
+            }
         });
-    };
-})();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        HtmlWebpackPlugin: ()=>html_webpack_plugin__WEBPACK_IMPORTED_MODULE_1___default.a,
-        rspack: ()=>_rspack_core__WEBPACK_IMPORTED_MODULE_0__.rspack,
-        webpack: ()=>webpack__WEBPACK_IMPORTED_MODULE_2___default.a
-    });
-    var _rspack_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@rspack/core");
-    var html_webpack_plugin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("html-webpack-plugin");
-    var html_webpack_plugin__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(html_webpack_plugin__WEBPACK_IMPORTED_MODULE_1__);
-    var webpack__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("webpack");
-    var webpack__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/ __webpack_require__.n(webpack__WEBPACK_IMPORTED_MODULE_2__);
-    var _colors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./colors");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _colors__WEBPACK_IMPORTED_MODULE_3__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _colors__WEBPACK_IMPORTED_MODULE_3__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _config__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./config");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _config__WEBPACK_IMPORTED_MODULE_4__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _config__WEBPACK_IMPORTED_MODULE_4__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _constants__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./constants");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _constants__WEBPACK_IMPORTED_MODULE_5__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _constants__WEBPACK_IMPORTED_MODULE_5__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _createUnpack__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./createUnpack");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _createUnpack__WEBPACK_IMPORTED_MODULE_6__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _createUnpack__WEBPACK_IMPORTED_MODULE_6__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _fs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("./fs");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _fs__WEBPACK_IMPORTED_MODULE_7__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _fs__WEBPACK_IMPORTED_MODULE_7__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _global__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__("./global");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _global__WEBPACK_IMPORTED_MODULE_8__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _global__WEBPACK_IMPORTED_MODULE_8__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _logger__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__("./logger");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _logger__WEBPACK_IMPORTED_MODULE_9__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _logger__WEBPACK_IMPORTED_MODULE_9__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _types_index__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__("src/types/index");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _types_index__WEBPACK_IMPORTED_MODULE_10__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _types_index__WEBPACK_IMPORTED_MODULE_10__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _utils__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__("./utils");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _utils__WEBPACK_IMPORTED_MODULE_11__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _utils__WEBPACK_IMPORTED_MODULE_11__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _watchFiles__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__("./watchFiles");
-    var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _watchFiles__WEBPACK_IMPORTED_MODULE_12__)if ([
-        "webpack",
-        "default",
-        "rspack",
-        "HtmlWebpackPlugin"
-    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _watchFiles__WEBPACK_IMPORTED_MODULE_12__[key];
-    }).bind(0, __WEBPACK_IMPORT_KEY__);
-    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-})();
-exports.HtmlWebpackPlugin = __webpack_exports__.HtmlWebpackPlugin;
-exports.rspack = __webpack_exports__.rspack;
-exports.webpack = __webpack_exports__.webpack;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    }
+    let external_node_assert_namespaceObject = require("node:assert");
+    var external_node_assert_default = __webpack_require__.n(external_node_assert_namespaceObject);
+    let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, SPLIT_STRATEGY_DISPATCHER = {
+        'split-by-experience': function(ctx) {
+            let { defaultConfig, forceSplittingGroups } = ctx, experienceCacheGroup = {};
+            for (let [name, test] of Object.entries({
+                axios: /node_modules[\\/]axios(-.+)?[\\/]/,
+                polyfill: /node_modules[\\/](?:tslib|core-js|@swc[\\/]helpers)[\\/]/
+            })){
+                let key = `lib-${name}`;
+                experienceCacheGroup[key] = {
+                    test,
+                    priority: 0,
+                    name: key
+                };
+            }
+            return {
+                ...defaultConfig,
+                cacheGroups: {
+                    ...defaultConfig.cacheGroups,
+                    ...experienceCacheGroup,
+                    ...forceSplittingGroups
+                }
+            };
+        },
+        'split-by-module': function(ctx) {
+            let { forceSplittingGroups, defaultConfig } = ctx;
+            return {
+                ...defaultConfig,
+                minSize: 0,
+                maxInitialRequests: Number.POSITIVE_INFINITY,
+                cacheGroups: {
+                    ...defaultConfig.cacheGroups,
+                    ...forceSplittingGroups,
+                    vendors: {
+                        priority: -9,
+                        test: NODE_MODULES_REGEX,
+                        name: (module)=>module ? function(modulePath) {
+                                let handleModuleContext = null == modulePath ? void 0 : modulePath.match(MODULE_PATH_REGEX);
+                                if (!handleModuleContext) return;
+                                let [, scope, name] = handleModuleContext;
+                                return [
+                                    'npm',
+                                    (scope ?? '').replace('@', ''),
+                                    name
+                                ].filter(Boolean).join('.');
+                            }(module.context) : void 0
+                    }
+                }
+            };
+        },
+        'split-by-size': function(ctx) {
+            let { forceSplittingGroups, defaultConfig, chunkSplit } = ctx;
+            return external_node_assert_default()('split-by-size' === chunkSplit.strategy), {
+                ...defaultConfig,
+                minSize: chunkSplit.minSize ?? 0,
+                maxSize: chunkSplit.maxSize ?? Number.POSITIVE_INFINITY,
+                cacheGroups: {
+                    ...defaultConfig.cacheGroups,
+                    ...forceSplittingGroups
+                }
+            };
+        },
+        custom: function(ctx) {
+            let { forceSplittingGroups, defaultConfig } = ctx;
+            return {
+                ...defaultConfig,
+                cacheGroups: {
+                    ...defaultConfig.cacheGroups,
+                    ...forceSplittingGroups
+                }
+            };
+        },
+        'all-in-one': function(_ctx) {
+            return !1;
+        },
+        'single-vendor': function(ctx) {
+            let { defaultConfig, forceSplittingGroups } = ctx;
+            return {
+                ...defaultConfig,
+                cacheGroups: {
+                    ...defaultConfig.cacheGroups,
+                    singleVendor: {
+                        test: NODE_MODULES_REGEX,
+                        priority: 0,
+                        chunks: 'all',
+                        name: 'vendor',
+                        enforce: !0
+                    },
+                    ...forceSplittingGroups
+                }
+            };
+        }
+    }, external_mini_css_extract_plugin_namespaceObject = require("mini-css-extract-plugin");
+    var external_mini_css_extract_plugin_default = __webpack_require__.n(external_mini_css_extract_plugin_namespaceObject);
+    let external_tinyglobby_namespaceObject = require("tinyglobby");
+    async function getEntry(root, customEntry) {
+        let entry;
+        return entry = customEntry ? external_node_path_default().resolve(root, customEntry) : (await (0, external_tinyglobby_namespaceObject.glob)('(index|Index).{js,ts,jsx,tsx}', {
+            cwd: external_node_path_default().join(root, 'src'),
+            absolute: !0
+        }))[0], external_node_fs_default().existsSync(entry) || (logger_logger.error(Error('could not find entry file')), process.exit(1)), entry;
+    }
+    let getOutputFilename = ({ type, hash, async })=>{
+        let FILENAME = isProd() && !1 !== hash ? PROD_DEFAULT_FILENAME : DEV_DEFAULT_FILENAME;
+        return async ? 'js' === type ? FILENAME.jsAsync : FILENAME.cssAsync : FILENAME[type];
+    }, external_typed_css_modules_namespaceObject = require("typed-css-modules");
+    var external_typed_css_modules_default = __webpack_require__.n(external_typed_css_modules_namespaceObject);
+    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;
+    }
+    let statPromise = external_node_fs_default().promises.stat, DtsCreator = external_typed_css_modules_default().default || external_typed_css_modules_default();
+    async function writeFile(dtsCreator, cssFile) {
+        let content = await dtsCreator.create(cssFile, void 0, !0);
+        await content.writeFile((definition)=>`// Generated automatically, do not edit\n${definition}`);
+    }
+    async function generateTypingIfNecessary(dtsCreator, cssFile) {
+        let typingStat;
+        try {
+            typingStat = await statPromise(`${cssFile}.d.ts`);
+        } catch  {
+            return writeFile(dtsCreator, cssFile);
+        }
+        if ((await statPromise(cssFile)).mtime.getTime() > typingStat.mtime.getTime()) return writeFile(dtsCreator, cssFile);
+    }
+    let typedCssModules_PLUGIN_NAME = 'TypedCssModulesPlugin';
+    class TypedCssModulesPlugin {
+        apply(compiler) {
+            compiler.hooks.run.tapPromise(typedCssModules_PLUGIN_NAME, async ()=>{
+                await this.generateCssTypings(this.useIncremental);
+            }), compiler.hooks.watchRun.tap(typedCssModules_PLUGIN_NAME, ()=>{
+                setTimeout(()=>{
+                    this.generateCssTypings(this.useIncremental).catch((err)=>{
+                        logger_logger.error(err.toString());
+                    }).finally(()=>{
+                        this.useIncremental = !0;
+                    });
+                }, 100);
+            });
+        }
+        async generateCssTypings(incremental) {
+            let cssModulesFiles = (await (0, external_tinyglobby_namespaceObject.glob)(this.globPattern)).filter((file)=>{
+                var _this_userOptions;
+                return isCSSModules({
+                    resourcePath: file,
+                    modules: null == (_this_userOptions = this.userOptions) ? void 0 : _this_userOptions.modules
+                });
+            }), doTask = incremental ? generateTypingIfNecessary : writeFile;
+            return Promise.all(cssModulesFiles.map((file)=>doTask(this.dtsCreator, file)));
+        }
+        constructor(options){
+            _define_property(this, "dtsCreator", void 0), _define_property(this, "useIncremental", !1), _define_property(this, "globPattern", 'src/**/*.{css,less,scss}'), _define_property(this, "userOptions", void 0), this.userOptions = options, this.dtsCreator = new DtsCreator({
+                camelCase: !0,
+                namedExports: CSS_NAMED_EXPORT
+            });
+        }
+    }
+    let external_oxc_minify_namespaceObject = require("oxc-minify");
+    function jsMinify_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;
+    }
+    let { RawSource: jsMinify_RawSource, SourceMapSource: jsMinify_SourceMapSource } = external_webpack_default().sources, isJsFile = /\.[cm]?js(\?.*)?$/i, jsMinify_PLUGIN_NAME = 'JsMinifyPlugin';
+    class JsMinifyPlugin {
+        apply(compiler) {
+            let meta = JSON.stringify({
+                name: jsMinify_PLUGIN_NAME,
+                version: "2.4.2",
+                options: this.minifyOptions
+            });
+            compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
+                compilation.hooks.chunkHash.tap(jsMinify_PLUGIN_NAME, (_, hash)=>hash.update(meta)), compilation.hooks.processAssets.tap({
+                    name: jsMinify_PLUGIN_NAME,
+                    stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+                    additionalAssets: !0
+                }, ()=>this.transformAssets(compilation)), compilation.hooks.statsPrinter.tap(jsMinify_PLUGIN_NAME, (stats)=>{
+                    stats.hooks.print.for('asset.info.minimized').tap(jsMinify_PLUGIN_NAME, (minimized, { green, formatFlag })=>minimized && green && formatFlag ? green(formatFlag('minimized')) : '');
+                });
+            });
+        }
+        transformAssets(compilation) {
+            let { options: { devtool } } = compilation.compiler, sourceMap = 'string' == typeof devtool && devtool.includes('source-map');
+            compilation.getAssets().filter((asset)=>!asset.info.minimized && isJsFile.test(asset.name)).map((asset)=>{
+                let { source, map } = asset.source.sourceAndMap(), { name } = asset, output = this.minify(name, Buffer.isBuffer(source) ? source.toString() : source, {
+                    sourcemap: sourceMap,
+                    ...this.minifyOptions
+                }), newMap = null;
+                output.map && ((newMap = 'string' == typeof output.map ? JSON.parse(output.map) : output.map).sources = [
+                    asset.name
+                ]);
+                let newSource = sourceMap && newMap ? new jsMinify_SourceMapSource(output.code, asset.name, newMap, source, map, !0) : new jsMinify_RawSource(output.code), newInfo = {
+                    ...asset.info,
+                    minimized: !0
+                };
+                compilation.updateAsset(asset.name, newSource, newInfo);
+            });
+        }
+        constructor(options = {}){
+            jsMinify_define_property(this, "minify", void 0), jsMinify_define_property(this, "minifyOptions", void 0);
+            let { implementation, ...minifyOptions } = options;
+            this.minify = (null == implementation ? void 0 : implementation.minify) ?? external_oxc_minify_namespaceObject.minify, this.minifyOptions = minifyOptions;
+        }
+    }
+    let external_node_buffer_namespaceObject = require("node:buffer");
+    function lightningcssMinify_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;
+    }
+    let lightningcssMinify_PLUGIN_NAME = 'LightningcssMinifyPlugin';
+    class LightningcssMinifyPlugin {
+        apply(compiler) {
+            compiler.hooks.compilation.tap(lightningcssMinify_PLUGIN_NAME, (compilation)=>{
+                compilation.hooks.processAssets.tap({
+                    name: lightningcssMinify_PLUGIN_NAME,
+                    stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE
+                }, ()=>this.transformAssets(compilation)), compilation.hooks.statsPrinter.tap(lightningcssMinify_PLUGIN_NAME, (statsPrinter)=>{
+                    statsPrinter.hooks.print.for('asset.info.minimized').tap(lightningcssMinify_PLUGIN_NAME, (minimized, { green, formatFlag })=>minimized && green && formatFlag ? green(formatFlag('minimized')) : '');
+                });
+            });
+        }
+        transformAssets(compilation) {
+            let { options: { devtool }, webpack: { sources: { SourceMapSource, RawSource } } } = compilation.compiler, sourceMap = 'string' == typeof devtool && devtool.includes('source-map');
+            compilation.getAssets().filter((asset)=>!asset.info.minimized && /\.css$/.test(asset.name)).map((asset)=>{
+                let { source, map } = asset.source.sourceAndMap(), sourceAsString = source.toString(), code = 'string' == typeof source ? external_node_buffer_namespaceObject.Buffer.from(source) : source, result = this.transform({
+                    filename: asset.name,
+                    code,
+                    minify: !0,
+                    sourceMap,
+                    ...this.transformOptions
+                }), codeString = result.code.toString();
+                compilation.updateAsset(asset.name, sourceMap ? new SourceMapSource(codeString, asset.name, JSON.parse(result.map.toString()), sourceAsString, map, !0) : new RawSource(codeString), {
+                    ...asset.info,
+                    minimized: !0
+                });
+            });
+        }
+        constructor(options = {}){
+            lightningcssMinify_define_property(this, "transform", void 0), lightningcssMinify_define_property(this, "transformOptions", void 0);
+            let { implementation, ...transformOptions } = options;
+            this.transform = (null == implementation ? void 0 : implementation.transform) ?? external_lightningcss_namespaceObject.transform, this.transformOptions = transformOptions;
+        }
+    }
+    let external_node_child_process_namespaceObject = require("node:child_process");
+    function oxlint_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 OxlintPlugin {
+        getGitChangedFiles() {
+            return new Promise((resolve)=>{
+                var _child_stdout;
+                let child = (0, external_node_child_process_namespaceObject.spawn)('git', [
+                    'status',
+                    '--porcelain'
+                ], {
+                    cwd: process.cwd(),
+                    stdio: 'pipe'
+                }), output = '';
+                null == (_child_stdout = child.stdout) || _child_stdout.on('data', (data)=>{
+                    output += data.toString();
+                }), child.on('exit', (code)=>{
+                    0 === code ? resolve(output.trim().split('\n').filter(Boolean).map((line)=>{
+                        let idx = line.indexOf(' '), status = line.slice(0, idx), filePath = line.slice(idx + 1).trim();
+                        return status.includes('D') ? null : ((status.startsWith('R') || status.startsWith('C')) && (filePath = filePath.split(' -> ')[1]), filePath);
+                    }).filter(Boolean).map((file)=>external_node_path_default().resolve(process.cwd(), file))) : resolve([]);
+                }), child.on('error', ()=>{
+                    resolve([]);
+                });
+            });
+        }
+        runOxlint(args) {
+            var _child_stdout, _child_stderr;
+            let cwd = process.cwd(), child = (0, external_node_child_process_namespaceObject.spawn)('npx', [
+                '--yes',
+                ...args
+            ], {
+                cwd,
+                stdio: 'pipe',
+                shell: !0,
+                env: {
+                    ...process.env,
+                    FORCE_COLOR: '1'
+                }
+            }), output = '';
+            null == (_child_stdout = child.stdout) || _child_stdout.on('data', (data)=>{
+                output += data.toString();
+            }), child.on('exit', (code)=>{
+                output.includes('Found 0 warnings and 0 errors') && 0 === code || process.stdout.write(output);
+            }), null == (_child_stderr = child.stderr) || _child_stderr.on('data', (data)=>{
+                process.stderr.write(data);
+            });
+        }
+        apply(compiler) {
+            compiler.hooks.watchRun.tap('OxlintPlugin', ()=>{
+                this.timeoutId && clearTimeout(this.timeoutId), this.timeoutId = setTimeout(()=>{
+                    let configPath = external_node_path_default().resolve(__dirname, '.oxlintrc.json');
+                    this.getGitChangedFiles().then((changedFiles)=>{
+                        if (changedFiles.length > 0) {
+                            let args = [
+                                'oxlint',
+                                '-c',
+                                configPath,
+                                ...changedFiles,
+                                '--fix',
+                                '--fix-suggestions'
+                            ];
+                            this.runOxlint(args);
+                        }
+                    });
+                }, this.debounceTime);
+            });
+        }
+        constructor(){
+            oxlint_define_property(this, "timeoutId", null), oxlint_define_property(this, "debounceTime", 200);
+        }
+    }
+    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 {
+        getCurrentChar() {
+            let now = Date.now();
+            return now - this.lastUpdateTime >= this.interval && (this.currentIndex = (this.currentIndex + 1) % this.chars.length, this.lastUpdateTime = now), this.chars[this.currentIndex];
+        }
+        reset() {
+            this.currentIndex = 0, this.lastUpdateTime = 0;
+        }
+        constructor(){
+            loadingAnimation_define_property(this, "chars", [
+                "\u280B",
+                "\u2819",
+                "\u2839",
+                "\u2838",
+                "\u283C",
+                "\u2834",
+                "\u2826",
+                "\u2827",
+                "\u2807",
+                "\u280F"
+            ]), loadingAnimation_define_property(this, "currentIndex", 0), loadingAnimation_define_property(this, "lastUpdateTime", 0), loadingAnimation_define_property(this, "interval", 150);
+        }
+    }
+    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 {
+        update({ current: originalCurrent, message = '' }) {
+            if (isCI()) return;
+            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, ' '))}`);
+        }
+        done() {
+            console.log();
+        }
+        constructor(){
+            progressBar_define_property(this, "prefix", 'transforming'), progressBar_define_property(this, "loadingAnimation", new LoadingAnimation());
+        }
+    }
+    let external_node_util_namespaceObject = require("node:util"), external_node_zlib_namespaceObject = require("node:zlib");
+    var external_node_zlib_default = __webpack_require__.n(external_node_zlib_namespaceObject);
+    let gzip = (0, external_node_util_namespaceObject.promisify)(external_node_zlib_default().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;
+    }
+    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), {}), compressedCount = 0, loadingAnimation = new LoadingAnimation();
+        logUpdate(`${loadingAnimation.getCurrentChar()} computing gzip size (0)...`);
+        let distPath = stats.compilation.outputOptions.path, distFolder = external_node_path_default().relative(root, distPath), origin = stats.toJson({
+            all: !1,
+            assets: !0,
+            cachedAssets: !0,
+            groupAssetsByInfo: !1,
+            groupAssetsByPath: !1,
+            groupAssetsByChunk: !1,
+            groupAssetsByExtension: !1,
+            groupAssetsByEmitStatus: !1
+        }), longest = 0, totalSize = 0, totalCompressedSize = 0;
+        await Promise.all(origin.assets.map(async (asset)=>{
+            let content = await external_node_fs_default().promises.readFile(external_node_path_default().join(distPath, asset.name)), size = content.length, compressedSize = await getCompressedSize(content);
+            totalSize += size, totalCompressedSize += compressedSize, compressedCount++, logUpdate(`${loadingAnimation.getCurrentChar()} computing gzip size (${compressedCount})...`), compressedCount === origin.assets.length && (logUpdate(`\u{2713} computed gzip size (${compressedCount})`), console.log());
+            let chunk = {
+                name: external_node_path_default().basename(asset.name),
+                path: `${distFolder}/${asset.name}`,
+                size,
+                compressedSize
+            };
+            switch(chunk.path.length > longest && (longest = chunk.path.length), external_node_path_default().extname(asset.name)){
+                case '.html':
+                    chunkGroupMap.HTML.chunks.push(chunk);
+                    break;
+                case '.css':
+                    chunkGroupMap.CSS.chunks.push(chunk);
+                    break;
+                case '.js':
+                    chunkGroupMap.JS.chunks.push(chunk);
+                    break;
+                default:
+                    chunkGroupMap.Assets.chunks.push(chunk);
+            }
+        }));
+        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 = external_node_path_default().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)), chunk.compressedSize && (log += colors.dim(` \u{2502} gzip: ${displaySize(chunk.compressedSize).padStart(compressPad)}`)), console.log(log);
+            });
+        });
+        let log = colors.blue('Total'.padEnd(longest + 2));
+        log += colors.blue(displaySize(totalSize)), console.log(log += colors.dim(` \u{2502} gzip: ${displaySize(totalCompressedSize)}`));
+    }
+    function isLikelyFile(filePath) {
+        return (filePath.split(external_node_path_namespaceObject.sep).pop() || '').includes('.');
+    }
+    function formatFileList(paths, rootPath) {
+        let files = paths.filter(isLikelyFile);
+        0 === files.length && (files = [
+            paths[0]
+        ]);
+        let fileInfo = files.slice(0, 1).map((file)=>(function(originalFilePath, root) {
+                let prefix = root.endsWith(external_node_path_namespaceObject.sep) ? root : root + external_node_path_namespaceObject.sep, filePath = originalFilePath;
+                filePath.startsWith(prefix) && (filePath = filePath.slice(prefix.length));
+                let parts = filePath.split(external_node_path_namespaceObject.sep).filter(Boolean);
+                return parts.length > 3 ? parts.slice(-3).join(external_node_path_namespaceObject.sep) : parts.join(external_node_path_namespaceObject.sep);
+            })(file, rootPath)).join(', ');
+        return files.length > 1 ? `${fileInfo} and ${files.length - 1} more` : fileInfo;
+    }
+    function printDevLog(compiler, root) {
+        let changedFiles = compiler.modifiedFiles ? Array.from(compiler.modifiedFiles) : null;
+        if (null == changedFiles ? void 0 : changedFiles.length) {
+            let fileInfo = formatFileList(changedFiles, root);
+            logger_logger.wait(`building ${colors.dim(fileInfo)}`);
+            return;
+        }
+        let removedFiles = compiler.removedFiles ? Array.from(compiler.removedFiles) : null;
+        if (null == removedFiles ? void 0 : removedFiles.length) {
+            let fileInfo = formatFileList(removedFiles, root);
+            logger_logger.wait(`building ${colors.dim(`removed ${fileInfo}`)}`);
+            return;
+        }
+        logger_logger.wait('building...');
+    }
+    async function compileDone(compiler, stats) {
+        let compileTime = stats.toJson({
+            preset: 'errors-only',
+            timings: !0
+        }).time / 1000, root = compiler.options.context;
+        if (!stats.hasErrors()) if (isProd()) isCI() || await printFileSize({
+            root,
+            stats
+        }), logger_logger.ready(colors.green(`built in ${prettyTime(compileTime)}`));
+        else {
+            if (isDebug()) {
+                let modules = stats.compilation.modules, nodeModulesStats = new Map(), nodeModulesPath = external_node_path_default().resolve(root, 'node_modules');
+                modules.forEach((module)=>{
+                    let { resource } = module;
+                    if (null == resource ? void 0 : resource.includes(nodeModulesPath)) {
+                        let packageName, pathParts = external_node_path_default().relative(nodeModulesPath, resource).split(external_node_path_namespaceObject.sep);
+                        (packageName = '.pnpm' === pathParts[0] && pathParts.length >= 4 ? pathParts[3].startsWith('@') ? `${pathParts[3]}/${pathParts[4]}` : pathParts[3] : pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0]) && nodeModulesStats.set(packageName, (nodeModulesStats.get(packageName) || 0) + 1);
+                    }
+                }), nodeModulesStats.size > 0 && Array.from(nodeModulesStats.entries()).sort((a, b)=>a[1] - b[1]).forEach(([packageName, count])=>{
+                    logger_logger.debug(`${colors.cyan(packageName)}: ${colors.yellow(count)} modules`);
+                });
+            }
+            logger_logger.ready(`built in ${prettyTime(compileTime)}${isDebug() ? ` (${stats.compilation.modules.size} modules)` : ''}`);
+        }
+    }
+    let rspack_PLUGIN_NAME = 'ProgressPlugin';
+    class ProgressRspackPlugin extends core_namespaceObject.rspack.ProgressPlugin {
+        apply(compiler) {
+            super.apply(compiler), compiler.hooks.watchRun.tap(rspack_PLUGIN_NAME, ()=>{
+                (!utils_isDevServer() || global.__unpack_dev_server_started) && printDevLog(compiler, compiler.options.context);
+            }), compiler.hooks.afterDone.tap(rspack_PLUGIN_NAME, async (stats)=>{
+                await compileDone(compiler, stats);
+            });
+        }
+        constructor(){
+            super((percentage, msg, ...args)=>{
+                isProd() && this.progressBar.update({
+                    current: percentage,
+                    message: `${msg} ${args.join(' ')}`
+                });
+            }), function(obj, key, value) {
+                key in obj ? Object.defineProperty(obj, key, {
+                    value: value,
+                    enumerable: !0,
+                    configurable: !0,
+                    writable: !0
+                }) : obj[key] = value;
+            }(this, "progressBar", new ProgressBar());
+        }
+    }
+    function webpack_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;
+    }
+    let webpack_PLUGIN_NAME = 'ProgressPlugin';
+    class ProgressWebpackPlugin extends external_webpack_default().ProgressPlugin {
+        apply(compiler) {
+            super.apply(compiler), compiler.hooks.watchRun.tap(webpack_PLUGIN_NAME, ()=>{
+                (!utils_isDevServer() || global.__unpack_dev_server_started) && printDevLog(compiler, compiler.options.context);
+            }), compiler.hooks.afterDone.tap(webpack_PLUGIN_NAME, async (stats)=>{
+                this.isCompleted = !0, await compileDone(compiler, stats);
+            });
+        }
+        constructor(){
+            super({
+                entries: !1,
+                dependencies: !1,
+                activeModules: !0,
+                handler: isProd() ? (percentage, msg, ...args)=>{
+                    this.isCompleted || this.progressBar.update({
+                        current: percentage,
+                        message: `${msg} ${args.join(' ').replace(/(\d+) active /, '')}`
+                    });
+                } : void 0
+            }), webpack_define_property(this, "progressBar", new ProgressBar()), webpack_define_property(this, "isCompleted", !1);
+        }
+    }
+    let BundleAnalyzerPlugin = __webpack_require__("compiled/webpack-bundle-analyzer").BundleAnalyzerPlugin;
+    async function getBundlerConfig(unpackConfig) {
+        var _unpackConfig_build, _unpackConfig_build1, _minifyOptions_oxc, _unpackConfig_build2, _unpackConfig_build3, _unpackConfig_build4, _unpackConfig_build5, _unpackConfig_build6, _unpackConfig_html, _unpackConfig_html1, _unpackConfig_html2, _unpackConfig_html3, _unpackConfig_html4, _unpackConfig_html5, _unpackConfig_html6, _unpackConfig_html7, _unpackConfig_html8, _unpackConfig_performance, _unpackConfig_performance1, _unpackConfig_build7, _unpackConfig_resolve, _unpackConfig_resolve1, _unpackConfig_dev, _unpackConfig_build8, _unpackConfig_experiments;
+        let define, isRspack = 'rspack' === unpackConfig.bundler, HtmlPlugin = isRspack ? core_namespaceObject.rspack.HtmlRspackPlugin : external_html_webpack_plugin_default(), IgnorePlugin = isRspack ? core_namespaceObject.rspack.IgnorePlugin : external_webpack_default().IgnorePlugin, CopyPlugin = isRspack ? core_namespaceObject.rspack.CopyRspackPlugin : external_copy_webpack_plugin_default(), tsconfigPath = external_node_path_default().resolve(unpackConfig.root, 'tsconfig.json'), isTs = external_node_fs_default().existsSync(tsconfigPath), minifyOptions = isPlainObject(null == (_unpackConfig_build = unpackConfig.build) ? void 0 : _unpackConfig_build.minify) ? null == (_unpackConfig_build1 = unpackConfig.build) ? void 0 : _unpackConfig_build1.minify : {}, oxcMinifyCompress = isPlainObject(null == (_minifyOptions_oxc = minifyOptions.oxc) ? void 0 : _minifyOptions_oxc.compress) ? minifyOptions.oxc.compress : {}, wasmFilename = 'js/[hash].module.wasm', { 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.`);
+            let filePaths = [
+                '.env',
+                '.env.local',
+                `.env.${mode}`,
+                `.env.${mode}.local`
+            ].map((filename)=>(0, external_node_path_namespaceObject.join)(cwd, filename)).filter(isFileSync), parsed = {};
+            for (let envPath of filePaths)Object.assign(parsed, function(src) {
+                let match, obj = {}, lines = src.toString();
+                for(lines = lines.replace(/\r\n?/gm, '\n'); null != (match = DOTENV_LINE.exec(lines));){
+                    let key = match[1], value = match[2] || '', maybeQuote = (value = value.trim())[0];
+                    value = value.replace(/^(['"`])([\s\S]*)\1$/gm, '$2'), '"' === maybeQuote && (value = (value = value.replace(/\\n/g, '\n')).replace(/\\r/g, '\r')), obj[key] = value;
+                }
+                return obj;
+            }(external_node_fs_default().readFileSync(envPath))), logger_logger.debug('loaded env file:', envPath);
+            parsed.NODE_ENV && (processEnv.NODE_ENV = parsed.NODE_ENV), (0, external_dotenv_expand_namespaceObject.expand)({
+                parsed,
+                processEnv
+            });
+            let publicVars = {}, rawPublicVars = {}, normalizedPrefixes = Array.isArray(prefixes) ? prefixes : [
+                prefixes
+            ];
+            for (let key of Object.keys(processEnv))if (normalizedPrefixes.some((prefix)=>key.startsWith(prefix))) {
+                let val = processEnv[key];
+                publicVars[`import.meta.env.${key}`] = JSON.stringify(val), publicVars[`process.env.${key}`] = JSON.stringify(val), rawPublicVars[key] = val;
+            }
+            publicVars['import.meta.env'] = JSON.stringify(rawPublicVars), publicVars['process.env'] = JSON.stringify(rawPublicVars);
+            let cleaned = !1;
+            return {
+                parsed,
+                cleanup: ()=>{
+                    if (!cleaned) {
+                        for (let key of Object.keys(parsed))'NODE_ENV' !== key && processEnv[key] === parsed[key] && delete processEnv[key];
+                        cleaned = !0;
+                    }
+                },
+                filePaths,
+                publicVars,
+                rawPublicVars
+            };
+        }({
+            prefixes: unpackConfig.envPrefix,
+            cwd: unpackConfig.root
+        }), config = {
+            context: unpackConfig.root,
+            mode: isDev() ? 'development' : 'production',
+            entry: unpackConfig.mpa ? {} : {
+                main: await getEntry(unpackConfig.root, unpackConfig.entry)
+            },
+            stats: 'errors-only',
+            output: {
+                clean: !0,
+                path: external_node_path_default().resolve(unpackConfig.root, null == (_unpackConfig_build2 = unpackConfig.build) ? void 0 : _unpackConfig_build2.outDir),
+                filename: getOutputFilename({
+                    type: 'js',
+                    hash: null == (_unpackConfig_build3 = unpackConfig.build) ? void 0 : _unpackConfig_build3.filenameHash
+                }),
+                chunkFilename: getOutputFilename({
+                    type: 'js',
+                    hash: null == (_unpackConfig_build4 = unpackConfig.build) ? void 0 : _unpackConfig_build4.filenameHash,
+                    async: !0
+                }),
+                crossOriginLoading: 'anonymous',
+                pathinfo: !1,
+                publicPath: null == (_unpackConfig_build5 = unpackConfig.build) ? void 0 : _unpackConfig_build5.publicPath,
+                webassemblyModuleFilename: wasmFilename,
+                assetModuleFilename: 'assets/[name].[contenthash:8][ext]'
+            },
+            infrastructureLogging: {
+                level: 'error'
+            },
+            devtool: null == (_unpackConfig_build6 = unpackConfig.build) ? void 0 : _unpackConfig_build6.sourceMap,
+            module: {
+                rules: [
+                    {
+                        test: /\.(png|jpg|jpeg|gif)$/i,
+                        type: 'asset'
+                    },
+                    {
+                        test: /\.(woff|woff2|eot|ttf|otf)$/i,
+                        type: 'asset'
+                    },
+                    {
+                        test: /\.wasm$/,
+                        dependency: 'url',
+                        type: 'asset/resource',
+                        generator: {
+                            filename: wasmFilename
+                        }
+                    }
+                ]
+            },
+            plugins: [
+                (define = {
+                    'import.meta.env.MODE': JSON.stringify(getNodeEnv()),
+                    'import.meta.env.DEV': isDev(),
+                    'import.meta.env.PROD': isProd(),
+                    ...publicVars,
+                    ...unpackConfig.define
+                }, isRspack ? new core_namespaceObject.rspack.DefinePlugin(define) : new (external_webpack_default()).DefinePlugin(define)),
+                !unpackConfig.mpa && new HtmlPlugin({
+                    template: (null == (_unpackConfig_html = unpackConfig.html) ? void 0 : _unpackConfig_html.template) || (isRspack ? void 0 : ''),
+                    templateContent: (null == (_unpackConfig_html1 = unpackConfig.html) ? void 0 : _unpackConfig_html1.templateContent) || ((null == (_unpackConfig_html2 = unpackConfig.html) ? void 0 : _unpackConfig_html2.template) ? !!isRspack && void 0 : TEMPLATE_CONTENT),
+                    templateParameters: {
+                        mountId: null == (_unpackConfig_html3 = unpackConfig.html) ? void 0 : _unpackConfig_html3.mountId,
+                        title: isFunction(null == (_unpackConfig_html4 = unpackConfig.html) ? void 0 : _unpackConfig_html4.title) ? null == (_unpackConfig_html5 = unpackConfig.html) ? void 0 : _unpackConfig_html5.title({
+                            entryName: 'index'
+                        }) : (null == (_unpackConfig_html6 = unpackConfig.html) ? void 0 : _unpackConfig_html6.title) || '',
+                        headTag: (null == (_unpackConfig_html7 = unpackConfig.html) ? void 0 : _unpackConfig_html7.headTag) || '',
+                        ...null == (_unpackConfig_html8 = unpackConfig.html) ? void 0 : _unpackConfig_html8.templateParameters
+                    },
+                    minify: !1,
+                    chunks: [
+                        'main'
+                    ]
+                }),
+                (null == (_unpackConfig_performance = unpackConfig.performance) ? void 0 : _unpackConfig_performance.bundleAnalyze) && isProd() && new BundleAnalyzerPlugin({
+                    analyzerPort: 'auto'
+                }),
+                (null == (_unpackConfig_performance1 = unpackConfig.performance) ? void 0 : _unpackConfig_performance1.removeMomentLocale) && new IgnorePlugin({
+                    resourceRegExp: /^\.\/locale$/,
+                    contextRegExp: /moment$/
+                }),
+                (null == (_unpackConfig_build7 = unpackConfig.build) ? void 0 : _unpackConfig_build7.copy) && new CopyPlugin({
+                    patterns: unpackConfig.build.copy
+                }),
+                unpackConfig.typeCheck && isDev() && isTs && new external_ts_checker_rspack_plugin_namespaceObject.TsCheckerRspackPlugin({
+                    typescript: {
+                        mode: 'readonly',
+                        memoryLimit: 8192,
+                        configFile: tsconfigPath,
+                        typescriptPath: require.resolve("typescript", {
+                            paths: [
+                                unpackConfig.root
+                            ]
+                        })
+                    },
+                    issue: {
+                        exclude: [
+                            ({ file = '' })=>NODE_MODULES_REGEX.test(file)
+                        ]
+                    },
+                    logger: {
+                        log (message) {
+                            message.includes('Found') && console.log(message.split(' in ')[0]);
+                        },
+                        error (message) {
+                            message.includes('RpcExitError') || message.includes('out of memory') || console.log(message.replace(/ERROR/g, 'Type Error'));
+                        }
+                    }
+                }),
+                new (isRspack ? ProgressRspackPlugin : ProgressWebpackPlugin)(),
+                unpackConfig.lint && new OxlintPlugin()
+            ].filter(Boolean),
+            externals: unpackConfig.externals,
+            resolve: {
+                alias: {
+                    '@': external_node_path_default().resolve(unpackConfig.root, 'src'),
+                    ...isTs ? (()=>{
+                        var _json5_parse_compilerOptions, _json5_parse;
+                        let paths = null == (_json5_parse = external_json5_default().parse(external_node_fs_default().readFileSync(tsconfigPath, 'utf-8'))) || null == (_json5_parse_compilerOptions = _json5_parse.compilerOptions) ? void 0 : _json5_parse_compilerOptions.paths;
+                        return paths ? Object.keys(paths).reduce((acc, key)=>(acc[key.replace(/\/\*$/, '')] = external_node_path_default().resolve(unpackConfig.root, paths[key][0].replace(/\/\*$/, '')), acc), {}) : {};
+                    })() : {},
+                    ...null == (_unpackConfig_resolve = unpackConfig.resolve) ? void 0 : _unpackConfig_resolve.alias
+                },
+                extensionAlias: {
+                    '.js': [
+                        '.js',
+                        '.ts',
+                        '.tsx'
+                    ],
+                    '.jsx': [
+                        '.jsx',
+                        '.tsx'
+                    ]
+                },
+                extensions: [
+                    '.tsx',
+                    '.ts',
+                    '.jsx',
+                    '.js',
+                    '.wasm',
+                    '.json',
+                    ...(null == (_unpackConfig_resolve1 = unpackConfig.resolve) ? void 0 : _unpackConfig_resolve1.extensions) || []
+                ]
+            },
+            experiments: {
+                lazyCompilation: (null == (_unpackConfig_dev = unpackConfig.dev) ? void 0 : _unpackConfig_dev.lazyCompilation) && utils_isDevServer() && {
+                    imports: !0,
+                    entries: !!unpackConfig.mpa
+                },
+                css: !1,
+                asyncWebAssembly: !0
+            },
+            optimization: {
+                moduleIds: isDev() ? 'named' : 'deterministic',
+                minimize: !!(null == (_unpackConfig_build8 = unpackConfig.build) ? void 0 : _unpackConfig_build8.minify),
+                minimizer: [
+                    new JsMinifyPlugin({
+                        ...minifyOptions.oxc,
+                        compress: {
+                            target: DEFAULT_ES_TARGET,
+                            ...oxcMinifyCompress
+                        }
+                    }),
+                    new LightningcssMinifyPlugin({
+                        targets: DEFAULT_LIGHTNINGCSS_TARGET,
+                        ...minifyOptions.lightningcss
+                    })
+                ]
+            },
+            watchOptions: {
+                ignored: /[\\/](?:\.git|node_modules)[\\/]/
+            }
+        };
+        for (let plugin of (config = (({ config, unpackConfig })=>{
+            let { chunkSplit } = unpackConfig.performance || {};
+            if (null == chunkSplit ? void 0 : chunkSplit.strategy) {
+                let forceSplittingGroups = {};
+                (null == chunkSplit ? void 0 : chunkSplit.forceSplitting) && (forceSplittingGroups = function(forceSplitting, strategy) {
+                    let cacheGroups = {};
+                    for (let [key, regexp] of Array.isArray(forceSplitting) ? forceSplitting.map((regexp, index)=>[
+                            `force-split-${index}`,
+                            regexp
+                        ]) : Object.entries(forceSplitting))cacheGroups[key] = {
+                        test: regexp,
+                        name: key,
+                        chunks: 'all',
+                        priority: +('single-vendor' === strategy),
+                        enforce: !0
+                    };
+                    return cacheGroups;
+                }(chunkSplit.forceSplitting, chunkSplit.strategy)), setValueByPath(config, [
+                    'optimization',
+                    'splitChunks'
+                ], SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy]({
+                    defaultConfig: {
+                        chunks: 'all'
+                    },
+                    forceSplittingGroups,
+                    chunkSplit
+                }));
+            }
+            return config;
+        })({
+            config: config = (null == (_unpackConfig_experiments = unpackConfig.experiments) ? void 0 : _unpackConfig_experiments.css) ? function({ config, unpackConfig }) {
+                var _unpackConfig_build, _unpackConfig_build1, _unpackConfig_css, _unpackConfig_css1, _config_module_rules, _config_module, _config_module_rules1, _config_module1, _config_module_rules2, _config_module2;
+                config.output.cssFilename = getOutputFilename({
+                    type: 'css',
+                    hash: null == (_unpackConfig_build = unpackConfig.build) ? void 0 : _unpackConfig_build.filenameHash
+                }), config.output.cssChunkFilename = getOutputFilename({
+                    type: 'css',
+                    hash: null == (_unpackConfig_build1 = unpackConfig.build) ? void 0 : _unpackConfig_build1.filenameHash,
+                    async: !0
+                }), setValueByPath(config, [
+                    'experiments',
+                    'css'
+                ], !0);
+                let sourceMap = null == (_unpackConfig_css = unpackConfig.css) ? void 0 : _unpackConfig_css.sourceMap, modules = null == (_unpackConfig_css1 = unpackConfig.css) ? void 0 : _unpackConfig_css1.modules;
+                isPlainObject(modules) || !1 === modules || (modules = {}), !1 !== modules && !1 !== modules.auto && (setValueByPath(config, [
+                    'module',
+                    'parser',
+                    'css/module'
+                ], {
+                    namedExports: CSS_NAMED_EXPORT
+                }), setValueByPath(config, [
+                    'module',
+                    'generator',
+                    'css/module'
+                ], {
+                    localIdentName: modules.localIdentName || CSS_MODULES_LOCAL_IDENT_NAME,
+                    exportsConvention: EXPORT_LOCALS_CONVENTION
+                }));
+                let withCssModules = ({ use })=>{
+                    if (!1 === modules) return !1;
+                    let auto = modules.auto;
+                    return !1 !== auto && {
+                        test: (resourcePath)=>resourcePath.includes('node_modules') ? CSS_MODULES_REGEX.test(resourcePath) : isRegExp(auto) ? auto.test(resourcePath) : isFunction(auto) ? auto(resourcePath) : CSS_MODULES_REGEX.test(resourcePath),
+                        use,
+                        type: 'css/module'
+                    };
+                }, getThreadLoader = ()=>{
+                    var _unpackConfig_build;
+                    return (null == (_unpackConfig_build = unpackConfig.build) ? void 0 : _unpackConfig_build.parallel) && isProd() && {
+                        loader: require.resolve('thread-loader'),
+                        options: THREAD_OPTIONS
+                    };
+                }, getLessLoader = ()=>{
+                    var _unpackConfig_css;
+                    return {
+                        loader: getCompiledPkgPath('less-loader'),
+                        options: {
+                            lessOptions: mergeConfig({
+                                javascriptEnabled: !0
+                            }, (null == (_unpackConfig_css = unpackConfig.css) ? void 0 : _unpackConfig_css.less) || {}),
+                            implementation: getUserDepPath(unpackConfig.root, 'less'),
+                            sourceMap
+                        }
+                    };
+                };
+                null == (_config_module = config.module) || null == (_config_module_rules = _config_module.rules) || _config_module_rules.push({
+                    test: /\.less$/i,
+                    oneOf: [
+                        withCssModules({
+                            use: [
+                                getThreadLoader(),
+                                getLessLoader()
+                            ].filter(Boolean)
+                        }),
+                        {
+                            use: [
+                                getThreadLoader(),
+                                getLessLoader()
+                            ].filter(Boolean),
+                            type: 'css'
+                        }
+                    ].filter(Boolean)
+                });
+                let getCssLoader = ()=>{
+                    var _unpackConfig_css, _unpackConfig_css1, _unpackConfig_css2;
+                    return (null == (_unpackConfig_css = unpackConfig.css) ? void 0 : _unpackConfig_css.transformer) === 'lightningcss' ? {
+                        loader: external_node_path_default().resolve(__dirname, './lightningcssLoader.mjs'),
+                        options: mergeConfig((null == (_unpackConfig_css1 = unpackConfig.css) ? void 0 : _unpackConfig_css1.lightningcss) || {}, {
+                            sourceMap,
+                            targets: DEFAULT_LIGHTNINGCSS_TARGET
+                        })
+                    } : {
+                        loader: getCompiledPkgPath('postcss-loader'),
+                        options: {
+                            postcssOptions: null == (_unpackConfig_css2 = unpackConfig.css) ? void 0 : _unpackConfig_css2.postcss,
+                            sourceMap
+                        }
+                    };
+                };
+                null == (_config_module1 = config.module) || null == (_config_module_rules1 = _config_module1.rules) || _config_module_rules1.push({
+                    test: /\.css$/i,
+                    oneOf: [
+                        withCssModules({
+                            use: [
+                                getCssLoader()
+                            ]
+                        }),
+                        {
+                            use: [
+                                getCssLoader()
+                            ],
+                            type: 'css'
+                        }
+                    ].filter(Boolean)
+                });
+                let getSassLoader = ()=>{
+                    var _unpackConfig_css;
+                    return {
+                        loader: getCompiledPkgPath('sass-loader'),
+                        options: {
+                            api: 'modern-compiler',
+                            implementation: getUserDepPath(unpackConfig.root, [
+                                'sass-embedded',
+                                'sass'
+                            ]),
+                            sassOptions: null == (_unpackConfig_css = unpackConfig.css) ? void 0 : _unpackConfig_css.sass,
+                            sourceMap
+                        }
+                    };
+                };
+                return null == (_config_module2 = config.module) || null == (_config_module_rules2 = _config_module2.rules) || _config_module_rules2.push({
+                    test: /\.s[ac]ss$/i,
+                    oneOf: [
+                        withCssModules({
+                            use: [
+                                getSassLoader()
+                            ]
+                        }),
+                        {
+                            use: [
+                                getSassLoader()
+                            ],
+                            type: 'css'
+                        }
+                    ].filter(Boolean)
+                }), isDev() && config.plugins.push(new TypedCssModulesPlugin({
+                    modules
+                })), config;
+            }({
+                config,
+                unpackConfig
+            }) : function({ config, unpackConfig }) {
+                var _unpackConfig_css, _unpackConfig_css1, _unpackConfig_build, _unpackConfig_css2, _config_module_rules, _config_module, _config_module_rules1, _config_module1, _unpackConfig_css3, _config_module_rules2, _config_module2, _unpackConfig_build1, _unpackConfig_build2, _unpackConfig_css4, _unpackConfig_css5, _unpackConfig_css6;
+                let CssExtractPlugin = 'rspack' === unpackConfig.bundler ? core_namespaceObject.rspack.CssExtractRspackPlugin : external_mini_css_extract_plugin_default(), sourceMap = null == (_unpackConfig_css = unpackConfig.css) ? void 0 : _unpackConfig_css.sourceMap, modules = null == (_unpackConfig_css1 = unpackConfig.css) ? void 0 : _unpackConfig_css1.modules;
+                isPlainObject(modules) || !1 === modules || (modules = {});
+                let getCommonRules = ({ importLoaders })=>[
+                        utils_isDevServer() ? {
+                            loader: getCompiledPkgPath('style-loader')
+                        } : {
+                            loader: CssExtractPlugin.loader,
+                            options: {
+                                defaultExport: !0
+                            }
+                        },
+                        isDev() && {
+                            loader: external_node_path_default().resolve(__dirname, './typedCssModulesLoader.mjs'),
+                            options: {
+                                modules
+                            }
+                        },
+                        {
+                            loader: getCompiledPkgPath('css-loader'),
+                            options: {
+                                importLoaders,
+                                modules: {
+                                    auto: (()=>{
+                                        if (!1 === modules) return !1;
+                                        let auto = modules.auto;
+                                        return !1 !== auto && ((resourcePath)=>resourcePath.includes('node_modules') ? CSS_MODULES_REGEX.test(resourcePath) : isRegExp(auto) ? auto.test(resourcePath) : isFunction(auto) ? auto(resourcePath) : CSS_MODULES_REGEX.test(resourcePath));
+                                    })(),
+                                    localIdentName: !1 !== modules && (modules.localIdentName || CSS_MODULES_LOCAL_IDENT_NAME),
+                                    exportLocalsConvention: EXPORT_LOCALS_CONVENTION,
+                                    namedExport: CSS_NAMED_EXPORT
+                                },
+                                sourceMap
+                            }
+                        }
+                    ].filter(Boolean);
+                return utils_isDevServer() || config.plugins.push(new CssExtractPlugin({
+                    filename: getOutputFilename({
+                        type: 'css',
+                        hash: null == (_unpackConfig_build1 = unpackConfig.build) ? void 0 : _unpackConfig_build1.filenameHash
+                    }),
+                    chunkFilename: getOutputFilename({
+                        type: 'css',
+                        hash: null == (_unpackConfig_build2 = unpackConfig.build) ? void 0 : _unpackConfig_build2.filenameHash,
+                        async: !0
+                    })
+                })), null == (_config_module = config.module) || null == (_config_module_rules = _config_module.rules) || _config_module_rules.push({
+                    test: /\.less$/i,
+                    use: [
+                        ...getCommonRules({
+                            importLoaders: 1
+                        }),
+                        (null == (_unpackConfig_build = unpackConfig.build) ? void 0 : _unpackConfig_build.parallel) && isProd() && {
+                            loader: require.resolve('thread-loader'),
+                            options: THREAD_OPTIONS
+                        },
+                        {
+                            loader: getCompiledPkgPath('less-loader'),
+                            options: {
+                                lessOptions: mergeConfig({
+                                    javascriptEnabled: !0
+                                }, (null == (_unpackConfig_css2 = unpackConfig.css) ? void 0 : _unpackConfig_css2.less) || {}),
+                                implementation: getUserDepPath(unpackConfig.root, 'less'),
+                                sourceMap
+                            }
+                        }
+                    ].filter(Boolean)
+                }), null == (_config_module1 = config.module) || null == (_config_module_rules1 = _config_module1.rules) || _config_module_rules1.push({
+                    test: /\.css$/i,
+                    use: [
+                        ...getCommonRules({
+                            importLoaders: 1
+                        }),
+                        (null == (_unpackConfig_css4 = unpackConfig.css) ? void 0 : _unpackConfig_css4.transformer) === 'lightningcss' ? {
+                            loader: external_node_path_default().resolve(__dirname, './lightningcssLoader.mjs'),
+                            options: mergeConfig((null == (_unpackConfig_css5 = unpackConfig.css) ? void 0 : _unpackConfig_css5.lightningcss) || {}, {
+                                sourceMap,
+                                targets: DEFAULT_LIGHTNINGCSS_TARGET
+                            })
+                        } : {
+                            loader: getCompiledPkgPath('postcss-loader'),
+                            options: {
+                                postcssOptions: null == (_unpackConfig_css6 = unpackConfig.css) ? void 0 : _unpackConfig_css6.postcss,
+                                sourceMap
+                            }
+                        }
+                    ]
+                }), null == (_config_module2 = config.module) || null == (_config_module_rules2 = _config_module2.rules) || _config_module_rules2.push({
+                    test: /\.s[ac]ss$/i,
+                    use: [
+                        ...getCommonRules({
+                            importLoaders: 1
+                        }),
+                        {
+                            loader: getCompiledPkgPath('sass-loader'),
+                            options: {
+                                api: 'modern-compiler',
+                                implementation: getUserDepPath(unpackConfig.root, [
+                                    'sass-embedded',
+                                    'sass'
+                                ]),
+                                sassOptions: null == (_unpackConfig_css3 = unpackConfig.css) ? void 0 : _unpackConfig_css3.sass,
+                                sourceMap
+                            }
+                        }
+                    ]
+                }), config;
+            }({
+                config,
+                unpackConfig
+            }),
+            unpackConfig
+        }), config = await applyCacheConfig({
+            config,
+            unpackConfig,
+            envFilePaths
+        }), 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, {
+            mergeConfig: mergeConfig
+        }) : mergeConfig(config, unpackConfig.bundlerConfig)), config;
+    }
+    async function unpackBuild(unpackConfig) {
+        let bundler = 'rspack' === unpackConfig.bundler ? core_namespaceObject.rspack : external_webpack_default(), compiler = bundler(await getBundlerConfig(unpackConfig)), handler = (err, stats)=>{
+            if (err) {
+                console.error(err.stack || err), err.details && console.error(err.details);
+                return;
+            }
+            (null == stats ? void 0 : stats.hasErrors()) && console.log(stats.toString({
+                colors: !0,
+                preset: 'errors-only'
+            })), isWatch() || compiler.close(()=>{});
+        };
+        isWatch() ? compiler.watch({}, handler) : compiler.run(handler);
+    }
+    let restartCleaners = [], external_open_namespaceObject = require("open");
+    var external_open_default = __webpack_require__.n(external_open_namespaceObject);
+    async function openBrowser(url) {
+        if ('darwin' === process.platform) try {
+            let ps = await execAsync('ps cax'), openedBrowser = [
+                'Google Chrome Canary',
+                'Google Chrome Dev',
+                'Google Chrome Beta',
+                'Google Chrome',
+                'Microsoft Edge',
+                'Brave Browser',
+                'Vivaldi',
+                'Chromium'
+            ].find((b)=>ps.includes(b));
+            if (openedBrowser) return await execAsync(`osascript openChrome.applescript "${encodeURI(url)}" "${openedBrowser}"`, {
+                cwd: external_node_path_default().join(__dirname, '../bin')
+            }), !0;
+        } catch (err) {
+            logger_logger.error(err);
+        }
+        try {
+            return external_open_default()(url).catch(()=>{}), !0;
+        } catch (err) {
+            return logger_logger.error(err), !1;
+        }
+    }
+    function execAsync(command, options) {
+        return new Promise((resolve, reject)=>{
+            (0, external_node_child_process_namespaceObject.exec)(command, options, (error, stdout)=>{
+                error ? reject(error) : resolve(stdout.toString());
+            });
+        });
+    }
+    let external_cors_namespaceObject = require("cors");
+    var external_cors_default = __webpack_require__.n(external_cors_namespaceObject);
+    let external_express_namespaceObject = require("express");
+    var external_express_default = __webpack_require__.n(external_express_namespaceObject);
+    let getExternalLibraryName = (pkgName)=>({
+            react: 'React',
+            'react-dom': 'ReactDOM',
+            'react-router-dom': 'ReactRouterDOM'
+        })[pkgName] || pkgName, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, prebundleDeps = async ({ unpackConfig })=>{
+        var _unpackConfig_dev;
+        let count = {
+            total: 0,
+            bundled: 0
+        }, failedDeps = [], root = unpackConfig.root, failedDepsCachePath = external_node_path_default().resolve(root, TEMP_DIR, 'failed-deps.json'), failedCache = ((failedDepsCachePath)=>external_node_fs_default().existsSync(failedDepsCachePath) ? JSON.parse(external_node_fs_default().readFileSync(failedDepsCachePath, 'utf-8')) : {})(failedDepsCachePath), updateProgress = ()=>{
+            logUpdate(`${colors.magenta("\xbb")} optimizing dependencies (${count.bundled}/${count.total})`), count.total === count.bundled + failedDeps.length && console.log();
+        }, userOptions = isPlainObject(null == (_unpackConfig_dev = unpackConfig.dev) ? void 0 : _unpackConfig_dev.prebundle) ? unpackConfig.dev.prebundle : {}, ignoreCSSDeps = userOptions.ignoreCSS || [], packageJson = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().resolve(root, 'package.json'), 'utf-8')), excludeDeps = [
+            ...((externals)=>{
+                let existExternals = new Set();
+                return 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);
+            })(unpackConfig.externals) || [],
+            ...userOptions.exclude || []
+        ], shouldIncludeDeps = Object.keys(packageJson.dependencies).filter((pkgName)=>!excludeDeps.includes(pkgName)), noEntryDeps = [], needBundleDeps = shouldIncludeDeps.map((pkgName)=>{
+            let packageJson = JSON.parse(external_node_fs_default().readFileSync(external_node_path_default().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) {
+                noEntryDeps.push(pkgName), failedCache[pkgName] = version;
+                return;
+            }
+            return {
+                name: pkgName,
+                entry: external_node_path_default().resolve(root, 'node_modules', pkgName, entry),
+                version
+            };
+        }).filter(Boolean), bundledDeps = await Promise.all(needBundleDeps.map((depInfo)=>(({ name, entry, version })=>new Promise((resolve)=>{
+                    let pkgDir = external_node_path_default().resolve(root, TEMP_DIR, 'umd', name), outDir = external_node_path_default().resolve(pkgDir, version), getResult = ()=>({
+                            name,
+                            assets: (0, external_tinyglobby_namespaceObject.globSync)('**/index.{js,css}', {
+                                cwd: outDir,
+                                absolute: !0
+                            })
+                        });
+                    if (external_node_fs_default().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 = (0, core_namespaceObject.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: {
+                            react: getExternalValue('react'),
+                            'react-dom': getExternalValue('react-dom'),
+                            'react-router-dom': getExternalValue('react-router-dom')
+                        }
+                    });
+                    compiler.run((_, stats)=>{
+                        let isFailed = !1;
+                        (null == stats ? void 0 : stats.hasErrors()) ? (isFailed = !0, failedDeps.push(name), failedCache[name] = version, removeDir(outDir)) : count.bundled++, updateProgress(), compiler.close(()=>{
+                            resolve(isFailed ? void 0 : getResult());
+                        });
+                    });
+                }))(depInfo)));
+        ((failedDepsCachePath, cache)=>{
+            let cacheDir = external_node_path_default().dirname(failedDepsCachePath);
+            external_node_fs_default().existsSync(cacheDir) || external_node_fs_default().mkdirSync(cacheDir, {
+                recursive: !0
+            }), external_node_fs_default().writeFileSync(failedDepsCachePath, JSON.stringify(cache, null, 2), 'utf-8');
+        })(failedDepsCachePath, failedCache), failedDeps[0] && logger_logger.warn(`something went wrong while optimizing "${colors.bold(failedDeps.join(', '))}"`);
+        let cachePath = external_node_path_default().resolve(root, TEMP_DIR, 'umd'), app = external_express_default()();
+        app.use(external_cors_default()()), app.use("/umd", external_express_default().static(cachePath));
+        let port = await getPort(), staticServer = app.listen(port, ()=>{});
+        restartCleaners.push(()=>new Promise((resolve)=>staticServer.close(()=>resolve())));
+        let externals = {}, jsAssets = [], cssAssets = [], preJsAssets = [];
+        bundledDeps.filter(Boolean).forEach((dep)=>{
+            dep && (externals[dep.name] = getExternalValue(dep.name), dep.assets.forEach((absPath)=>{
+                let relativePath = external_node_path_default().relative(cachePath, absPath), preDeps = [
+                    'react',
+                    'react-dom',
+                    'react-router-dom'
+                ], serverPath = `//localhost:${port}/umd/${relativePath}`;
+                switch(external_node_path_default().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);
+                }
+            }));
+        }), unpackConfig.externals = Array.isArray(unpackConfig.externals) ? [
+            externals,
+            ...unpackConfig.externals
+        ] : {
+            ...externals,
+            ...unpackConfig.externals
+        };
+        let HtmlPlugin = 'rspack' === unpackConfig.bundler ? core_namespaceObject.rspack.HtmlRspackPlugin : external_html_webpack_plugin_default();
+        return unpackConfig.plugins.push({
+            name: 'unpack:prebundle',
+            bundlerConfig: (config)=>{
+                let PLUGIN_NAME = 'PluginInjectAssets';
+                return config.plugins.push({
+                    apply: (compiler)=>{
+                        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+                            HtmlPlugin.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(PLUGIN_NAME, async (args)=>{
+                                let sortedPreJsAssets = preJsAssets.sort((a, b)=>a.order - b.order).map((item)=>item.path);
+                                return args.assets.js.unshift(...sortedPreJsAssets, ...jsAssets), args.assets.css.unshift(...cssAssets), args;
+                            });
+                        });
+                    }
+                }), config;
+            }
+        }), unpackConfig;
+    }, external_webpack_dev_server_namespaceObject = require("webpack-dev-server");
+    var external_webpack_dev_server_default = __webpack_require__.n(external_webpack_dev_server_namespaceObject);
+    async function unpackDev(originalUnpackConfig) {
+        var _unpackConfig_dev, _unpackConfig_server, _unpackConfig_server1, _unpackConfig_dev1, _unpackConfig_server2;
+        let unpackConfig = originalUnpackConfig, isRspack = 'rspack' === unpackConfig.bundler, bundler = isRspack ? core_namespaceObject.rspack : external_webpack_default();
+        (null == (_unpackConfig_dev = unpackConfig.dev) ? void 0 : _unpackConfig_dev.prebundle) && (unpackConfig = await prebundleDeps({
+            unpackConfig
+        }));
+        let compiler = bundler(await getBundlerConfig(unpackConfig)), port = await getPort(null == (_unpackConfig_server = unpackConfig.server) ? void 0 : _unpackConfig_server.port), proxyConfig = null == (_unpackConfig_server1 = unpackConfig.server) ? void 0 : _unpackConfig_server1.proxy;
+        isPlainObject(proxyConfig) && (proxyConfig = Object.entries(proxyConfig).map(([contextStr, target])=>({
+                context: contextStr.split(','),
+                target,
+                changeOrigin: !0
+            })));
+        let devServerOptions = {
+            hot: !0,
+            port,
+            open: !1,
+            client: {
+                overlay: !1
+            },
+            proxy: proxyConfig,
+            devMiddleware: {
+                writeToDisk: null == (_unpackConfig_dev1 = unpackConfig.dev) ? void 0 : _unpackConfig_dev1.writeToDisk
+            }
+        };
+        devServerOptions.setupMiddlewares = (middlewares)=>(middlewares.unshift((req, _, next)=>{
+                var _req_headers_accept;
+                (null == (_req_headers_accept = req.headers.accept) ? void 0 : _req_headers_accept.includes('html')) && (req.url = '/index.html'), next();
+            }), isRspack && middlewares.unshift(core_namespaceObject.experiments.lazyCompilationMiddleware(compiler)), middlewares);
+        let server = new (external_webpack_dev_server_default())(devServerOptions, compiler);
+        await server.start(), logger_logger.greet(`  ${colors.green(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v2.4.2`)}  ${colors.dim(`ready in ${colors.reset(Math.ceil(performance.now() - global.__unpack_start_time))}ms`)}\n`), function(port) {
+            let addressUrls = getAddressUrls({
+                port
+            });
+            addressUrls.forEach((addr)=>{
+                let url;
+                console.log(`  ${colors.green(colors.dim("\u279C"))}  ${colors.dim(addr.label)}${(url = addr.url, colors.cyan(url.replace(/:(\d+)\//, (_, port)=>`:${colors.bold(port)}/`)))}`);
+            });
+        }(port), logger_logger.wait('building...'), global.__unpack_dev_server_started = !0, restartCleaners.push(async ()=>await server.stop(), ()=>new Promise((resolve)=>compiler.close(()=>resolve())), ()=>{
+            global.__unpack_dev_server_started = !1;
+        });
+        let open = null == (_unpackConfig_server2 = unpackConfig.server) ? void 0 : _unpackConfig_server2.open;
+        if (open) {
+            let url = isString(open) ? open : `http://localhost:${port}`;
+            await openBrowser(url);
+        }
+    }
+    function createUnpack({ cwd = process.cwd(), config, callerName = 'unpack' }) {
+        let resolveConfig = async ()=>{
+            let defaultConfig = {
+                bundler: 'rspack',
+                root: cwd,
+                build: {
+                    outDir: 'dist',
+                    minify: isProd(),
+                    sourceMap: !isProd() && 'cheap-module-source-map',
+                    parallel: !0,
+                    filenameHash: !0
+                },
+                dev: {
+                    lazyCompilation: !0
+                },
+                server: {
+                    port: 3000
+                },
+                html: {
+                    mountId: 'root'
+                },
+                css: {
+                    modules: !0,
+                    transformer: 'postcss',
+                    sourceMap: !1
+                },
+                performance: {
+                    chunkSplit: {
+                        strategy: 'split-by-experience'
+                    }
+                },
+                typeCheck: !0,
+                envPrefix: [
+                    'PUBLIC_'
+                ]
+            }, _context = {
+                callerName,
+                version: "2.4.2"
+            }, { plugins, bundlerConfig, ...rest } = mergeConfig(defaultConfig, config);
+            for (let plugin of getNormalizedPluginsByHook('config', plugins))rest = await plugin.config(rest, {
+                ..._context,
+                mergeConfig: mergeConfig
+            });
+            return {
+                ...rest,
+                plugins,
+                bundlerConfig,
+                _context
+            };
+        };
+        return {
+            build: async ({ watch } = {})=>{
+                setNodeEnv(watch ? 'development' : 'production'), console.log(colors.rainbow(`${callerName} v2.4.2`), colors.green(`building for ${watch ? 'development' : 'production'}...`)), unpackBuild(await resolveConfig());
+            },
+            dev: async ()=>{
+                global.__unpack_start_time = performance.now(), setNodeEnv('development'), setDevServer(!0), unpackDev(await resolveConfig());
+            }
+        };
+    }
+    let external_chokidar_namespaceObject = require("chokidar");
+    var external_chokidar_default = __webpack_require__.n(external_chokidar_namespaceObject);
+    let GLOB_REGEX = /[*?{}[\]()!@+|]/;
+    async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
+        let watchFiles = new Set(), globPatterns = pathOrGlobs.filter((pathOrGlob)=>{
+            let str;
+            return str = pathOrGlob, !!GLOB_REGEX.test(str) || (watchFiles.add(pathOrGlob), !1);
+        });
+        if (globPatterns.length) for (let file of (await (0, external_tinyglobby_namespaceObject.glob)(globPatterns, {
+            cwd: root,
+            absolute: !0
+        })))watchFiles.add(file);
+        return external_chokidar_default().watch(Array.from(watchFiles), {
+            ignoreInitial: !0,
+            ignorePermissionErrors: !0,
+            ...options
+        });
+    }
+})(), exports.CSS_MODULES_LOCAL_IDENT_NAME = __webpack_exports__.CSS_MODULES_LOCAL_IDENT_NAME, exports.CSS_MODULES_REGEX = __webpack_exports__.CSS_MODULES_REGEX, exports.CSS_NAMED_EXPORT = __webpack_exports__.CSS_NAMED_EXPORT, exports.DEFAULT_BROWSERSLIST = __webpack_exports__.DEFAULT_BROWSERSLIST, exports.DEFAULT_DEV_HOST = __webpack_exports__.DEFAULT_DEV_HOST, exports.DEFAULT_ES_TARGET = __webpack_exports__.DEFAULT_ES_TARGET, exports.DEFAULT_LIGHTNINGCSS_TARGET = __webpack_exports__.DEFAULT_LIGHTNINGCSS_TARGET, exports.DEV_DEFAULT_FILENAME = __webpack_exports__.DEV_DEFAULT_FILENAME, exports.EXPORT_LOCALS_CONVENTION = __webpack_exports__.EXPORT_LOCALS_CONVENTION, exports.HtmlWebpackPlugin = __webpack_exports__.HtmlWebpackPlugin, exports.LogColor = __webpack_exports__.LogColor, exports.NODE_MODULES_REGEX = __webpack_exports__.NODE_MODULES_REGEX, exports.PROD_DEFAULT_FILENAME = __webpack_exports__.PROD_DEFAULT_FILENAME, exports.TEMPLATE_CONTENT = __webpack_exports__.TEMPLATE_CONTENT, exports.TEMP_DIR = __webpack_exports__.TEMP_DIR, exports.THREAD_OPTIONS = __webpack_exports__.THREAD_OPTIONS, exports.clearLine = __webpack_exports__.clearLine, exports.colors = __webpack_exports__.colors, exports.createChokidar = __webpack_exports__.createChokidar, exports.createUnpack = __webpack_exports__.createUnpack, exports.debounce = __webpack_exports__.debounce, exports.defineConfig = __webpack_exports__.defineConfig, exports.findExists = __webpack_exports__.findExists, exports.getAddressUrls = __webpack_exports__.getAddressUrls, exports.getCompiledPkgPath = __webpack_exports__.getCompiledPkgPath, exports.getIpv4Interfaces = __webpack_exports__.getIpv4Interfaces, exports.getNodeEnv = __webpack_exports__.getNodeEnv, exports.getPathInJs = __webpack_exports__.getPathInJs, exports.getPort = __webpack_exports__.getPort, exports.getTime = __webpack_exports__.getTime, exports.getUserDepPath = __webpack_exports__.getUserDepPath, exports.getUserDepVersion = __webpack_exports__.getUserDepVersion, exports.getValueByPath = __webpack_exports__.getValueByPath, exports.isBoolean = __webpack_exports__.isBoolean, exports.isCI = __webpack_exports__.isCI, exports.isCSSModules = __webpack_exports__.isCSSModules, exports.isDebug = __webpack_exports__.isDebug, exports.isDev = __webpack_exports__.isDev, exports.isDevServer = __webpack_exports__.isDevServer, exports.isEmptyDir = __webpack_exports__.isEmptyDir, exports.isFileExists = __webpack_exports__.isFileExists, exports.isFileSync = __webpack_exports__.isFileSync, exports.isFunction = __webpack_exports__.isFunction, exports.isNodeVersionAtLeast = __webpack_exports__.isNodeVersionAtLeast, exports.isObject = __webpack_exports__.isObject, exports.isPlainObject = __webpack_exports__.isPlainObject, exports.isProd = __webpack_exports__.isProd, exports.isRegExp = __webpack_exports__.isRegExp, exports.isString = __webpack_exports__.isString, exports.isUndefined = __webpack_exports__.isUndefined, exports.isWatch = __webpack_exports__.isWatch, exports.isWin = __webpack_exports__.isWin, exports.loadConfig = __webpack_exports__.loadConfig, exports.logUpdate = __webpack_exports__.logUpdate, exports.logger = __webpack_exports__.logger, exports.mergeConfig = __webpack_exports__.mergeConfig, exports.pathExists = __webpack_exports__.pathExists, exports.prettyTime = __webpack_exports__.prettyTime, exports.removeDir = __webpack_exports__.removeDir, exports.resolveConfigPath = __webpack_exports__.resolveConfigPath, exports.restartCleaners = __webpack_exports__.restartCleaners, exports.rspack = __webpack_exports__.rspack, exports.setDevServer = __webpack_exports__.setDevServer, exports.setNodeEnv = __webpack_exports__.setNodeEnv, exports.setValueByPath = __webpack_exports__.setValueByPath, exports.trackPerformance = __webpack_exports__.trackPerformance, exports.webpack = __webpack_exports__.webpack, __webpack_exports__)-1 === [
+    "CSS_MODULES_LOCAL_IDENT_NAME",
+    "CSS_MODULES_REGEX",
+    "CSS_NAMED_EXPORT",
+    "DEFAULT_BROWSERSLIST",
+    "DEFAULT_DEV_HOST",
+    "DEFAULT_ES_TARGET",
+    "DEFAULT_LIGHTNINGCSS_TARGET",
+    "DEV_DEFAULT_FILENAME",
+    "EXPORT_LOCALS_CONVENTION",
     "HtmlWebpackPlugin",
+    "LogColor",
+    "NODE_MODULES_REGEX",
+    "PROD_DEFAULT_FILENAME",
+    "TEMPLATE_CONTENT",
+    "TEMP_DIR",
+    "THREAD_OPTIONS",
+    "clearLine",
+    "colors",
+    "createChokidar",
+    "createUnpack",
+    "debounce",
+    "defineConfig",
+    "findExists",
+    "getAddressUrls",
+    "getCompiledPkgPath",
+    "getIpv4Interfaces",
+    "getNodeEnv",
+    "getPathInJs",
+    "getPort",
+    "getTime",
+    "getUserDepPath",
+    "getUserDepVersion",
+    "getValueByPath",
+    "isBoolean",
+    "isCI",
+    "isCSSModules",
+    "isDebug",
+    "isDev",
+    "isDevServer",
+    "isEmptyDir",
+    "isFileExists",
+    "isFileSync",
+    "isFunction",
+    "isNodeVersionAtLeast",
+    "isObject",
+    "isPlainObject",
+    "isProd",
+    "isRegExp",
+    "isString",
+    "isUndefined",
+    "isWatch",
+    "isWin",
+    "loadConfig",
+    "logUpdate",
+    "logger",
+    "mergeConfig",
+    "pathExists",
+    "prettyTime",
+    "removeDir",
+    "resolveConfigPath",
+    "restartCleaners",
     "rspack",
+    "setDevServer",
+    "setNodeEnv",
+    "setValueByPath",
+    "trackPerformance",
     "webpack"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__webpack_i__) && (exports[__webpack_i__] = __webpack_exports__[__webpack_i__]);
 Object.defineProperty(exports, '__esModule', {
-    value: true
+    value: !0
 });