@unpackjs/core 2.4.1 → 2.4.2

package/dist/index.js

@@ -1,47 +1,1884 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-import * as __WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__ from "./types/index.js";
-import * as __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__ from "@rspack/core";
-import * as __WEBPACK_EXTERNAL_MODULE_html_webpack_plugin_e07f62c9__ from "html-webpack-plugin";
-import * as __WEBPACK_EXTERNAL_MODULE_webpack__ from "webpack";
-export * from "./colors.js";
-export * from "./config.js";
-export * from "./constants.js";
-export * from "./createUnpack.js";
-export * from "./fs.js";
-export * from "./global.js";
-export * from "./logger.js";
-export * from "./utils.js";
-export * from "./watchFiles.js";
-var __webpack_modules__ = {
-    "src/types/index": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__types_index_js_63ede62f__;
+import __rslib_shim_module__ from 'module';
+let require = __rslib_shim_module__.createRequire(import.meta.url);
+import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
+import { dirname as __webpack_dirname__ } from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_webpack_bundle_analyzer_index_js_1177eada__ from "../compiled/webpack-bundle-analyzer/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__compiled_webpack_merge_index_js_efd91626__ from "../compiled/webpack-merge/index.js";
+import { experiments, rspack } from "@rspack/core";
+import html_webpack_plugin from "html-webpack-plugin";
+import webpack from "webpack";
+import picocolors from "picocolors";
+import node_fs from "node:fs";
+import node_path, { isAbsolute, join, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
+import node_readline from "node:readline";
+import node_net from "node:net";
+import node_os from "node:os";
+import portfinder from "portfinder";
+import { browserslistToTargets, transform } from "lightningcss";
+import copy_webpack_plugin from "copy-webpack-plugin";
+import json5 from "json5";
+import { expand } from "dotenv-expand";
+import { TsCheckerRspackPlugin } from "ts-checker-rspack-plugin";
+import node_assert from "node:assert";
+import mini_css_extract_plugin from "mini-css-extract-plugin";
+import { glob, globSync } from "tinyglobby";
+import typed_css_modules from "typed-css-modules";
+import { minify } from "oxc-minify";
+import { Buffer as external_node_buffer_Buffer } from "node:buffer";
+import { exec, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import node_zlib from "node:zlib";
+import open_0 from "open";
+import cors from "cors";
+import express from "express";
+import webpack_dev_server from "webpack-dev-server";
+import chokidar from "chokidar";
+var LogColor, __webpack_modules__ = {
+    "compiled/webpack-bundle-analyzer": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__compiled_webpack_bundle_analyzer_index_js_1177eada__;
     },
-    "@rspack/core": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__;
-    },
-    "html-webpack-plugin": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_html_webpack_plugin_e07f62c9__;
-    },
-    webpack: function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_webpack__;
+    "compiled/webpack-merge": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE__compiled_webpack_merge_index_js_efd91626__;
     }
-};
-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;
-}
-var core_ = __webpack_require__("@rspack/core");
-var external_html_webpack_plugin_ = __webpack_require__("html-webpack-plugin");
-var external_webpack_ = __webpack_require__("webpack");
-__webpack_require__("src/types/index");
-var __webpack_exports__HtmlWebpackPlugin = external_html_webpack_plugin_["default"];
-var __webpack_exports__rspack = core_.rspack;
-var __webpack_exports__webpack = external_webpack_["default"];
-export { __webpack_exports__HtmlWebpackPlugin as HtmlWebpackPlugin, __webpack_exports__rspack as rspack, __webpack_exports__webpack as webpack };
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
+}
+let colors = {
+    ...picocolors,
+    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;
+    }
+};
+var logger_LogColor = ((LogColor = {}).error = "red", LogColor.warn = "yellow", LogColor.info = "cyan", LogColor.ready = "green", LogColor.event = "magenta", LogColor.wait = "blue", LogColor.debug = "dim", LogColor);
+let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULES_REGEX = /\.module\.\w+$/i, DEV_DEFAULT_FILENAME = {
+    js: 'js/[name].js',
+    jsAsync: 'js/async/[name].js',
+    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 = 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>`;
+var utils_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+let { 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)=>{
+        portfinder.getPort({
+            port: startPort
+        }, (_, port)=>{
+            resolve(port);
+        });
+    }), getCompiledPkgPath = (packageName)=>node_path.join(utils_dirname, '../compiled', packageName), getUserDepPath = (root, deps)=>{
+    for (let dep of Array.isArray(deps) ? deps : [
+        deps
+    ]){
+        let absPath = node_path.resolve(root, 'node_modules', dep);
+        if (node_fs.existsSync(absPath)) return absPath;
+    }
+};
+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 = node_os.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: node_net.isIPv6(host) ? '::' === host ? '[::1]' : `[${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(node_fs.readFileSync(node_path.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) : ''), node_readline.cursorTo(process.stdout, 0, 0), node_readline.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;
+})();
+var config_filename = __webpack_fileURLToPath__(import.meta.url);
+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) ? node_path.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 = 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 = createJiti(config_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 = isAbsolute(customConfig) ? customConfig : join(root, customConfig);
+        if (node_fs.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 = join(root, file);
+        if (node_fs.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 isFileSync = (filePath)=>{
+    try {
+        var _fs_statSync;
+        return null == (_fs_statSync = node_fs.statSync(filePath, {
+            throwIfNoEntry: !1
+        })) ? void 0 : _fs_statSync.isFile();
+    } catch (_) {
+        return !1;
+    }
+};
+function isEmptyDir(path) {
+    let files = node_fs.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;
+};
+async function pathExists(path) {
+    return node_fs.promises.access(path).then(()=>!0).catch(()=>!1);
+}
+async function isFileExists(file) {
+    return node_fs.promises.access(file, node_fs.constants.F_OK).then(()=>!0).catch(()=>!1);
+}
+let removeDir = (dir)=>{
+    node_fs.rmSync(dir, {
+        recursive: !0,
+        force: !0
+    });
+}, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+async function getBuildDependencies(root, userBuildDependencies, envFilePaths) {
+    let rootPackageJson = node_path.join(root, 'package.json'), browserslistConfig = node_path.join(root, '.browserslistrc'), tsconfigPath = node_path.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)=>node_path.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 = node_path.isAbsolute(cacheDirectory) ? cacheDirectory : node_path.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
+        }
+    });
+}
+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 node_assert('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
+            }
+        };
+    }
+};
+async function getEntry(root, customEntry) {
+    let entry;
+    return entry = customEntry ? node_path.resolve(root, customEntry) : (await glob('(index|Index).{js,ts,jsx,tsx}', {
+        cwd: node_path.join(root, 'src'),
+        absolute: !0
+    }))[0], node_fs.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];
+};
+var css_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+function _define_property(obj, key, value) {
+    return key in obj ? Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : obj[key] = value, obj;
+}
+let statPromise = node_fs.promises.stat, DtsCreator = typed_css_modules.default || typed_css_modules;
+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 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
+        });
+    }
+}
+var experimentCss_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+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 } = webpack.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) ?? minify, this.minifyOptions = minifyOptions;
+    }
+}
+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_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) ?? transform, this.transformOptions = transformOptions;
+    }
+}
+var oxlint_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+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 = 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)=>node_path.resolve(process.cwd(), file))) : resolve([]);
+            }), child.on('error', ()=>{
+                resolve([]);
+            });
+        });
+    }
+    runOxlint(args) {
+        var _child_stdout, _child_stderr;
+        let child = spawn('npx', [
+            '--yes',
+            ...args
+        ], {
+            cwd: process.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 = node_path.resolve(oxlint_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 gzip = promisify(node_zlib.gzip), numberFormatter = new Intl.NumberFormat('en', {
+    maximumFractionDigits: 2,
+    minimumFractionDigits: 2
+}), displaySize = (bytes)=>`${numberFormatter.format(bytes / 1000)} kB`;
+async function getCompressedSize(content) {
+    return (await gzip(content)).length;
+}
+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 = node_path.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 node_fs.promises.readFile(node_path.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: node_path.basename(asset.name),
+            path: `${distFolder}/${asset.name}`,
+            size,
+            compressedSize
+        };
+        switch(chunk.path.length > longest && (longest = chunk.path.length), node_path.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 = node_path.dirname(chunk.path) + '/', log = colors.dim(relativeOutDir);
+            log += colors[group.color](chunk.name.padEnd(longest + 2 - relativeOutDir.length)), log += colors[isLarge ? 'yellow' : 'dim'](displaySize(chunk.size).padStart(sizePad)), 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(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(sep) ? root : root + sep, filePath = originalFilePath;
+            filePath.startsWith(prefix) && (filePath = filePath.slice(prefix.length));
+            let parts = filePath.split(sep).filter(Boolean);
+            return parts.length > 3 ? parts.slice(-3).join(sep) : parts.join(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 = node_path.resolve(root, 'node_modules');
+            modules.forEach((module)=>{
+                let { resource } = module;
+                if (null == resource ? void 0 : resource.includes(nodeModulesPath)) {
+                    let packageName, pathParts = node_path.relative(nodeModulesPath, resource).split(sep);
+                    (packageName = '.pnpm' === pathParts[0] && pathParts.length >= 4 ? pathParts[3].startsWith('@') ? `${pathParts[3]}/${pathParts[4]}` : pathParts[3] : pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0]) && nodeModulesStats.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 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(){
+        var key, value;
+        super((percentage, msg, ...args)=>{
+            isProd() && this.progressBar.update({
+                current: percentage,
+                message: `${msg} ${args.join(' ')}`
+            });
+        }), key = "progressBar", value = new ProgressBar(), key in this ? Object.defineProperty(this, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : this[key] = value;
+    }
+}
+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 webpack.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 ? rspack.HtmlRspackPlugin : html_webpack_plugin, IgnorePlugin = isRspack ? rspack.IgnorePlugin : webpack.IgnorePlugin, CopyPlugin = isRspack ? rspack.CopyRspackPlugin : copy_webpack_plugin, tsconfigPath = node_path.resolve(unpackConfig.root, 'tsconfig.json'), isTs = node_fs.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)=>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;
+        }(node_fs.readFileSync(envPath))), logger_logger.debug('loaded env file:', envPath);
+        parsed.NODE_ENV && (processEnv.NODE_ENV = parsed.NODE_ENV), 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: node_path.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 rspack.DefinePlugin(define) : new webpack.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 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: {
+                '@': node_path.resolve(unpackConfig.root, 'src'),
+                ...isTs ? (()=>{
+                    var _json5_parse_compilerOptions, _json5_parse;
+                    let paths = null == (_json5_parse = json5.parse(node_fs.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(/\/\*$/, '')] = node_path.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: node_path.resolve(experimentCss_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 ? rspack.CssExtractRspackPlugin : mini_css_extract_plugin, 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: node_path.resolve(css_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: node_path.resolve(css_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 compiler = ('rspack' === unpackConfig.bundler ? rspack : webpack)(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 = [];
+var openBrowser_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+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: node_path.join(openBrowser_dirname, '../bin')
+        }), !0;
+    } catch (err) {
+        logger_logger.error(err);
+    }
+    try {
+        return open_0(url).catch(()=>{}), !0;
+    } catch (err) {
+        return logger_logger.error(err), !1;
+    }
+}
+function execAsync(command, options) {
+    return new Promise((resolve, reject)=>{
+        exec(command, options, (error, stdout)=>{
+            error ? reject(error) : resolve(stdout.toString());
+        });
+    });
+}
+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 = node_path.resolve(root, TEMP_DIR, 'failed-deps.json'), failedCache = node_fs.existsSync(failedDepsCachePath) ? JSON.parse(node_fs.readFileSync(failedDepsCachePath, 'utf-8')) : {}, 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(node_fs.readFileSync(node_path.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(node_fs.readFileSync(node_path.resolve(root, 'node_modules', pkgName, 'package.json'), 'utf-8')), version = packageJson.version;
+        if (failedCache[pkgName] === version) return;
+        let entry = ((packageJson)=>{
+            if (packageJson.module) return packageJson.module;
+            if (packageJson.exports) {
+                if (isString(packageJson.exports)) return packageJson.exports;
+                let defaultExport = packageJson.exports['.'];
+                if (defaultExport) {
+                    if (isString(defaultExport)) return defaultExport;
+                    if (isString(defaultExport.import)) return defaultExport.import;
+                    if (isString(defaultExport.browser)) return defaultExport.browser;
+                    if (isString(defaultExport.default)) return defaultExport.default;
+                }
+                if (isString(packageJson.exports.default)) return packageJson.exports.default;
+            }
+            if (packageJson.main) return packageJson.main;
+        })(packageJson);
+        if (!entry) {
+            noEntryDeps.push(pkgName), failedCache[pkgName] = version;
+            return;
+        }
+        return {
+            name: pkgName,
+            entry: node_path.resolve(root, 'node_modules', pkgName, entry),
+            version
+        };
+    }).filter(Boolean), bundledDeps = await Promise.all(needBundleDeps.map((depInfo)=>(({ name, entry, version })=>new Promise((resolve)=>{
+                let pkgDir = node_path.resolve(root, TEMP_DIR, 'umd', name), outDir = node_path.resolve(pkgDir, version), getResult = ()=>({
+                        name,
+                        assets: globSync('**/index.{js,css}', {
+                            cwd: outDir,
+                            absolute: !0
+                        })
+                    });
+                if (node_fs.existsSync(outDir)) return void resolve(getResult());
+                count.total++, updateProgress();
+                let getSwcOptions = ({ tsx })=>({
+                        jsc: {
+                            parser: {
+                                tsx,
+                                syntax: "typescript",
+                                dynamicImport: !0,
+                                decorators: !0
+                            },
+                            transform: {
+                                react: {
+                                    runtime: 'automatic'
+                                }
+                            }
+                        }
+                    }), compiler = rspack({
+                    entry: {
+                        index: entry
+                    },
+                    context: root,
+                    mode: 'development',
+                    output: {
+                        clean: !0,
+                        path: outDir,
+                        pathinfo: !1,
+                        library: {
+                            name: getExternalLibraryName(name),
+                            type: 'umd',
+                            umdNamedDefine: !0
+                        },
+                        globalObject: 'this'
+                    },
+                    devtool: !1,
+                    module: {
+                        rules: [
+                            {
+                                test: /\.(j|t)s$/,
+                                use: [
+                                    {
+                                        loader: 'builtin:swc-loader',
+                                        options: getSwcOptions({
+                                            tsx: !1
+                                        })
+                                    }
+                                ]
+                            },
+                            {
+                                test: /\.(j|t)sx$/,
+                                use: [
+                                    {
+                                        loader: 'builtin:swc-loader',
+                                        options: getSwcOptions({
+                                            tsx: !0
+                                        })
+                                    }
+                                ]
+                            },
+                            {
+                                test: /\.less$/,
+                                type: 'css/auto',
+                                use: [
+                                    {
+                                        loader: getCompiledPkgPath('less-loader'),
+                                        options: {
+                                            lessOptions: {
+                                                javascriptEnabled: !0
+                                            },
+                                            implementation: getUserDepPath(root, 'less')
+                                        }
+                                    }
+                                ]
+                            },
+                            {
+                                test: /\.s[ac]ss$/i,
+                                type: 'css/auto',
+                                use: [
+                                    {
+                                        loader: getCompiledPkgPath('sass-loader'),
+                                        options: {
+                                            api: 'modern-compiler',
+                                            implementation: getUserDepPath(root, [
+                                                'sass-embedded',
+                                                'sass'
+                                            ])
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    optimization: {
+                        splitChunks: !1
+                    },
+                    experiments: {
+                        css: !0
+                    },
+                    externals: {
+                        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))), cacheDir = node_path.dirname(failedDepsCachePath);
+    node_fs.existsSync(cacheDir) || node_fs.mkdirSync(cacheDir, {
+        recursive: !0
+    }), node_fs.writeFileSync(failedDepsCachePath, JSON.stringify(failedCache, null, 2), 'utf-8'), failedDeps[0] && logger_logger.warn(`something went wrong while optimizing "${colors.bold(failedDeps.join(', '))}"`);
+    let cachePath = node_path.resolve(root, TEMP_DIR, 'umd'), app = express();
+    app.use(cors()), app.use("/umd", express.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 = node_path.relative(cachePath, absPath), preDeps = [
+                'react',
+                'react-dom',
+                'react-router-dom'
+            ], serverPath = `//localhost:${port}/umd/${relativePath}`;
+            switch(node_path.extname(relativePath)){
+                case '.js':
+                    preDeps.includes(dep.name) ? preJsAssets.push({
+                        path: serverPath,
+                        order: preDeps.indexOf(dep.name)
+                    }) : jsAssets.push(serverPath);
+                    break;
+                case '.css':
+                    ignoreCSSDeps.includes(dep.name) || cssAssets.push(serverPath);
+            }
+        }));
+    }), unpackConfig.externals = Array.isArray(unpackConfig.externals) ? [
+        externals,
+        ...unpackConfig.externals
+    ] : {
+        ...externals,
+        ...unpackConfig.externals
+    };
+    let HtmlPlugin = 'rspack' === unpackConfig.bundler ? rspack.HtmlRspackPlugin : html_webpack_plugin;
+    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;
+};
+async function unpackDev(originalUnpackConfig) {
+    var _unpackConfig_dev, _unpackConfig_server, _unpackConfig_server1, _unpackConfig_dev1, _unpackConfig_server2;
+    let unpackConfig = originalUnpackConfig, isRspack = 'rspack' === unpackConfig.bundler, bundler = isRspack ? rspack : webpack;
+    (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(experiments.lazyCompilationMiddleware(compiler)), middlewares);
+    let server = new webpack_dev_server(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`), getAddressUrls({
+        port: port
+    }).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)}/`)))}`);
+    }), 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 GLOB_REGEX = /[*?{}[\]()!@+|]/;
+async function createChokidar(pathOrGlobs, root = process.cwd(), options) {
+    let watchFiles = new Set(), globPatterns = pathOrGlobs.filter((pathOrGlob)=>!!GLOB_REGEX.test(pathOrGlob) || (watchFiles.add(pathOrGlob), !1));
+    if (globPatterns.length) for (let file of (await glob(globPatterns, {
+        cwd: root,
+        absolute: !0
+    })))watchFiles.add(file);
+    return chokidar.watch(Array.from(watchFiles), {
+        ignoreInitial: !0,
+        ignorePermissionErrors: !0,
+        ...options
+    });
+}
+export { 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, html_webpack_plugin as HtmlWebpackPlugin, logger_LogColor as 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, utils_isDevServer as isDevServer, isEmptyDir, isFileExists, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isProd, isRegExp, isString, isUndefined, isWatch, isWin, loadConfig, logUpdate, logger_logger as logger, mergeConfig, pathExists, prettyTime, removeDir, resolveConfigPath, restartCleaners, rspack, setDevServer, setNodeEnv, setValueByPath, trackPerformance, webpack };