@unpackjs/core 4.7.2 → 4.7.4

package/dist/index.js

@@ -1,9 +1,9 @@
 /*! For license information please see index.js.LICENSE.txt */
-let lastTrackTime, devServerPort, lastFileInfo, logger;
+let runtimeProcessArgs, runtimeInfo, lastTrackTime, devServerPort, lastFileInfo, logger;
 import __rslib_shim_module__ from "node:module";
 let require = __rslib_shim_module__.createRequire(import.meta.url);
 import { fileURLToPath as __rspack_fileURLToPath, pathToFileURL } from "node:url";
-import node_path, { dirname as __rspack_dirname, join, sep } from "node:path";
+import node_path, { dirname as __rspack_dirname, basename as external_node_path_basename, dirname as external_node_path_dirname, extname, isAbsolute, join, normalize, relative as external_node_path_relative, resolve as external_node_path_resolve, sep } from "node:path";
 import * as __rspack_external_child_process from "child_process";
 import * as __rspack_external_fs from "fs";
 import * as __rspack_external_os from "os";
@@ -11,22 +11,36 @@ import * as __rspack_external_path from "path";
 import * as __rspack_external_url from "url";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { Compilation, rspack } from "@rspack/core";
-import cac from "cac";
-import node_fs from "node:fs";
+import { exec, spawn, spawnSync } from "node:child_process";
+import node_fs, { stat as external_node_fs_stat, unwatchFile, watch as external_node_fs_watch, watchFile } from "node:fs";
 import node_readline from "node:readline";
 import { createHash } from "node:crypto";
-import node_os, { platform } from "node:os";
-import portfinder from "portfinder";
-import { glob as external_tinyglobby_glob, globSync } from "tinyglobby";
-import { format, promisify } from "node:util";
-import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
-import { parse } from "stacktrace-parser";
+import node_os, { platform, type as external_node_os_type } from "node:os";
+import { createRequire } from "module";
+import { format as external_node_util_format, promisify } from "node:util";
 import node_zlib from "node:zlib";
-import magic_string from "magic-string";
-import { expand } from "dotenv-expand";
+import node_net from "node:net";
 import { RspackDevServer } from "@rspack/dev-server";
-import { exec, spawn } from "node:child_process";
-import chokidar from "chokidar";
+import { EventEmitter } from "node:events";
+import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "node:fs/promises";
+import { Readable } from "node:stream";
+function toArr(any) {
+    return null == any ? [] : Array.isArray(any) ? any : [
+        any
+    ];
+}
+function removeBrackets(v) {
+    return v.replace(/[<[].+/, "").trim();
+}
+function findLongest(arr) {
+    return arr.sort((a, b)=>a.length > b.length ? -1 : 1)[0];
+}
+function padRight(str, length) {
+    return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcaseOptionName(name) {
+    return name.split(".").map((v, i)=>0 === i ? v.replaceAll(/([a-z])-([a-z])/g, (_, p1, p2)=>p1 + p2.toUpperCase()) : v).join(".");
+}
 __webpack_require__.add({
     "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         let clone = __webpack_require__("../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js"), typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"), isPlainObject = __webpack_require__("../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js");
@@ -51,6 +65,36 @@ __webpack_require__.add({
             }
         };
     },
+    "../../node_modules/.pnpm/dotenv-expand@12.0.3/node_modules/dotenv-expand/lib/main.js" (module) {
+        function _resolveEscapeSequences(value) {
+            return value.replace(/\\\$/g, '$');
+        }
+        module.exports.expand = function(options) {
+            let runningParsed = {}, processEnv = process.env;
+            for(let key in options && null != options.processEnv && (processEnv = options.processEnv), options.parsed){
+                let value = options.parsed[key];
+                value = processEnv[key] && processEnv[key] !== value ? processEnv[key] : function(value, processEnv, runningParsed) {
+                    let match, env = {
+                        ...runningParsed,
+                        ...processEnv
+                    }, regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g, result = value, seen = new Set();
+                    for(; null !== (match = regex.exec(result));){
+                        let defaultValue, value;
+                        seen.add(result);
+                        let [template, bracedExpression, unbracedExpression] = match, expression = bracedExpression || unbracedExpression, opRegex = /(:\+|\+|:-|-)/, opMatch = expression.match(opRegex), splitter = opMatch ? opMatch[0] : null, r = expression.split(splitter), key = r.shift();
+                        if ([
+                            ':+',
+                            '+'
+                        ].includes(splitter) ? (defaultValue = env[key] ? r.join(splitter) : '', value = null) : (defaultValue = r.join(splitter), value = env[key]), (result = value ? seen.has(value) ? result.replace(template, defaultValue) : result.replace(template, value) : result.replace(template, defaultValue)) === runningParsed[key]) break;
+                        regex.lastIndex = 0;
+                    }
+                    return result;
+                }(value, processEnv, runningParsed), options.parsed[key] = _resolveEscapeSequences(value), runningParsed[key] = _resolveEscapeSequences(value);
+            }
+            for(let processKey in options.parsed)processEnv[processKey] = options.parsed[processKey];
+            return options;
+        };
+    },
     "../../node_modules/.pnpm/flat@5.0.2/node_modules/flat/index.js" (module) {
         function isBuffer(obj) {
             return obj && obj.constructor && 'function' == typeof obj.constructor.isBuffer && obj.constructor.isBuffer(obj);
@@ -558,6 +602,945 @@ __webpack_require__.add({
         };
         module.exports = createColors(), module.exports.createColors = createColors;
     },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js"), utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js");
+        function picomatch(glob, options, returnState = !1) {
+            return options && (null === options.windows || void 0 === options.windows) && (options = {
+                ...options,
+                windows: utils.isWindows()
+            }), pico(glob, options, returnState);
+        }
+        Object.assign(picomatch, pico), module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js" (module) {
+        let WIN_NO_SLASH = "[^\\\\/]", QMARK = '[^/]', END_ANCHOR = "(?:\\/|$)", START_ANCHOR = "(?:^|\\/)", DOTS_SLASH = `\\.{1,2}${END_ANCHOR}`, NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`, NO_DOT_SLASH = `(?!\\.{0,1}${END_ANCHOR})`, NO_DOTS_SLASH = `(?!${DOTS_SLASH})`, STAR = `${QMARK}*?`, POSIX_CHARS = {
+            DOT_LITERAL: '\\.',
+            PLUS_LITERAL: '\\+',
+            QMARK_LITERAL: '\\?',
+            SLASH_LITERAL: '\\/',
+            ONE_CHAR: '(?=.)',
+            QMARK,
+            END_ANCHOR,
+            DOTS_SLASH,
+            NO_DOT: "(?!\\.)",
+            NO_DOTS,
+            NO_DOT_SLASH,
+            NO_DOTS_SLASH,
+            QMARK_NO_DOT: "[^.\\/]",
+            STAR,
+            START_ANCHOR,
+            SEP: '/'
+        }, WINDOWS_CHARS = {
+            ...POSIX_CHARS,
+            SLASH_LITERAL: "[\\\\/]",
+            QMARK: WIN_NO_SLASH,
+            STAR: `${WIN_NO_SLASH}*?`,
+            DOTS_SLASH: "\\.{1,2}(?:[\\\\/]|$)",
+            NO_DOT: "(?!\\.)",
+            NO_DOTS: "(?!(?:^|[\\\\/])\\.{1,2}(?:[\\\\/]|$))",
+            NO_DOT_SLASH: "(?!\\.{0,1}(?:[\\\\/]|$))",
+            NO_DOTS_SLASH: "(?!\\.{1,2}(?:[\\\\/]|$))",
+            QMARK_NO_DOT: "[^.\\\\/]",
+            START_ANCHOR: "(?:^|[\\\\/])",
+            END_ANCHOR: "(?:[\\\\/]|$)",
+            SEP: '\\'
+        };
+        module.exports = {
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE: {
+                alnum: 'a-zA-Z0-9',
+                alpha: 'a-zA-Z',
+                ascii: '\\x00-\\x7F',
+                blank: ' \\t',
+                cntrl: '\\x00-\\x1F\\x7F',
+                digit: '0-9',
+                graph: '\\x21-\\x7E',
+                lower: 'a-z',
+                print: '\\x20-\\x7E ',
+                punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+                space: ' \\t\\r\\n\\v\\f',
+                upper: 'A-Z',
+                word: 'A-Za-z0-9_',
+                xdigit: 'A-Fa-f0-9'
+            },
+            REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+            REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+            REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+            REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+            REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+            REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+            REPLACEMENTS: {
+                __proto__: null,
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            CHAR_0: 48,
+            CHAR_9: 57,
+            CHAR_UPPERCASE_A: 65,
+            CHAR_LOWERCASE_A: 97,
+            CHAR_UPPERCASE_Z: 90,
+            CHAR_LOWERCASE_Z: 122,
+            CHAR_LEFT_PARENTHESES: 40,
+            CHAR_RIGHT_PARENTHESES: 41,
+            CHAR_ASTERISK: 42,
+            CHAR_AMPERSAND: 38,
+            CHAR_AT: 64,
+            CHAR_BACKWARD_SLASH: 92,
+            CHAR_CARRIAGE_RETURN: 13,
+            CHAR_CIRCUMFLEX_ACCENT: 94,
+            CHAR_COLON: 58,
+            CHAR_COMMA: 44,
+            CHAR_DOT: 46,
+            CHAR_DOUBLE_QUOTE: 34,
+            CHAR_EQUAL: 61,
+            CHAR_EXCLAMATION_MARK: 33,
+            CHAR_FORM_FEED: 12,
+            CHAR_FORWARD_SLASH: 47,
+            CHAR_GRAVE_ACCENT: 96,
+            CHAR_HASH: 35,
+            CHAR_HYPHEN_MINUS: 45,
+            CHAR_LEFT_ANGLE_BRACKET: 60,
+            CHAR_LEFT_CURLY_BRACE: 123,
+            CHAR_LEFT_SQUARE_BRACKET: 91,
+            CHAR_LINE_FEED: 10,
+            CHAR_NO_BREAK_SPACE: 160,
+            CHAR_PERCENT: 37,
+            CHAR_PLUS: 43,
+            CHAR_QUESTION_MARK: 63,
+            CHAR_RIGHT_ANGLE_BRACKET: 62,
+            CHAR_RIGHT_CURLY_BRACE: 125,
+            CHAR_RIGHT_SQUARE_BRACKET: 93,
+            CHAR_SEMICOLON: 59,
+            CHAR_SINGLE_QUOTE: 39,
+            CHAR_SPACE: 32,
+            CHAR_TAB: 9,
+            CHAR_UNDERSCORE: 95,
+            CHAR_VERTICAL_LINE: 124,
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+            extglobChars: (chars)=>({
+                    '!': {
+                        type: 'negate',
+                        open: '(?:(?!(?:',
+                        close: `))${chars.STAR})`
+                    },
+                    '?': {
+                        type: 'qmark',
+                        open: '(?:',
+                        close: ')?'
+                    },
+                    '+': {
+                        type: 'plus',
+                        open: '(?:',
+                        close: ')+'
+                    },
+                    '*': {
+                        type: 'star',
+                        open: '(?:',
+                        close: ')*'
+                    },
+                    '@': {
+                        type: 'at',
+                        open: '(?:',
+                        close: ')'
+                    }
+                }),
+            globChars: (win32)=>!0 === win32 ? WINDOWS_CHARS : POSIX_CHARS
+        };
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let constants = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js"), utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js"), { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants, expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            let value = `[${args.join('-')}]`;
+            try {
+                new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        }, syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`, parse = (input, options)=>{
+            let value;
+            if ('string' != typeof input) throw TypeError('Expected a string');
+            input = REPLACEMENTS[input] || input;
+            let opts = {
+                ...options
+            }, max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH, len = input.length;
+            if (len > max) throw SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            let bos = {
+                type: 'bos',
+                value: '',
+                output: opts.prepend || ''
+            }, tokens = [
+                bos
+            ], capture = opts.capture ? '' : '?:', PLATFORM_CHARS = constants.globChars(opts.windows), EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS), { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS, globstar = (opts)=>`(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`, nodot = opts.dot ? '' : NO_DOT, qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT, star = !0 === opts.bash ? globstar(opts) : STAR;
+            opts.capture && (star = `(${star})`), 'boolean' == typeof opts.noext && (opts.noextglob = opts.noext);
+            let state = {
+                input,
+                index: -1,
+                start: 0,
+                dot: !0 === opts.dot,
+                consumed: '',
+                output: '',
+                prefix: '',
+                backtrack: !1,
+                negated: !1,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: !1,
+                tokens
+            };
+            len = (input = utils.removePrefix(input, state)).length;
+            let extglobs = [], braces = [], stack = [], prev = bos, eos = ()=>state.index === len - 1, peek = state.peek = (n = 1)=>input[state.index + n], advance = state.advance = ()=>input[++state.index] || '', remaining = ()=>input.slice(state.index + 1), consume = (value = '', num = 0)=>{
+                state.consumed += value, state.index += num;
+            }, append = (token)=>{
+                state.output += null != token.output ? token.output : token.value, consume(token.value);
+            }, negate = ()=>{
+                let count = 1;
+                for(; '!' === peek() && ('(' !== peek(2) || '?' === peek(3));)advance(), state.start++, count++;
+                return count % 2 != 0 && (state.negated = !0, state.start++, !0);
+            }, increment = (type)=>{
+                state[type]++, stack.push(type);
+            }, decrement = (type)=>{
+                state[type]--, stack.pop();
+            }, push = (tok)=>{
+                if ('globstar' === prev.type) {
+                    let isBrace = state.braces > 0 && ('comma' === tok.type || 'brace' === tok.type), isExtglob = !0 === tok.extglob || extglobs.length && ('pipe' === tok.type || 'paren' === tok.type);
+                    'slash' === tok.type || 'paren' === tok.type || isBrace || isExtglob || (state.output = state.output.slice(0, -prev.output.length), prev.type = 'star', prev.value = '*', prev.output = star, state.output += prev.output);
+                }
+                if (extglobs.length && 'paren' !== tok.type && (extglobs[extglobs.length - 1].inner += tok.value), (tok.value || tok.output) && append(tok), prev && 'text' === prev.type && 'text' === tok.type) {
+                    prev.output = (prev.output || prev.value) + tok.value, prev.value += tok.value;
+                    return;
+                }
+                tok.prev = prev, tokens.push(tok), prev = tok;
+            }, extglobOpen = (type, value)=>{
+                let token = {
+                    ...EXTGLOB_CHARS[value],
+                    conditions: 1,
+                    inner: ''
+                };
+                token.prev = prev, token.parens = state.parens, token.output = state.output;
+                let output = (opts.capture ? '(' : '') + token.open;
+                increment('parens'), push({
+                    type,
+                    value,
+                    output: state.output ? '' : ONE_CHAR
+                }), push({
+                    type: 'paren',
+                    extglob: !0,
+                    value: advance(),
+                    output
+                }), extglobs.push(token);
+            }, extglobClose = (token)=>{
+                let rest, output = token.close + (opts.capture ? ')' : '');
+                if ('negate' === token.type) {
+                    let extglobStar = star;
+                    if (token.inner && token.inner.length > 1 && token.inner.includes('/') && (extglobStar = globstar(opts)), (extglobStar !== star || eos() || /^\)+$/.test(remaining())) && (output = token.close = `)$))${extglobStar}`), token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                        let expression = parse(rest, {
+                            ...options,
+                            fastpaths: !1
+                        }).output;
+                        output = token.close = `)${expression})${extglobStar})`;
+                    }
+                    'bos' === token.prev.type && (state.negatedExtglob = !0);
+                }
+                push({
+                    type: 'paren',
+                    extglob: !0,
+                    value,
+                    output
+                }), decrement('parens');
+            };
+            if (!1 !== opts.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+                let backslashes = !1, output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>'\\' === first ? (backslashes = !0, m) : '?' === first ? esc ? esc + first + (rest ? QMARK.repeat(rest.length) : '') : 0 === index ? qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '') : QMARK.repeat(chars.length) : '.' === first ? DOT_LITERAL.repeat(chars.length) : '*' === first ? esc ? esc + first + (rest ? star : '') : star : esc ? m : `\\${m}`);
+                return (!0 === backslashes && (output = !0 === opts.unescape ? output.replace(/\\/g, '') : output.replace(/\\+/g, (m)=>m.length % 2 == 0 ? '\\\\' : m ? '\\' : '')), output === input && !0 === opts.contains) ? state.output = input : state.output = utils.wrapOutput(output, state, options), state;
+            }
+            for(; !eos();){
+                if ('\u0000' === (value = advance())) continue;
+                if ('\\' === value) {
+                    let next = peek();
+                    if ('/' === next && !0 !== opts.bash || '.' === next || ';' === next) continue;
+                    if (!next) {
+                        push({
+                            type: 'text',
+                            value: value += '\\'
+                        });
+                        continue;
+                    }
+                    let match = /^\\+/.exec(remaining()), slashes = 0;
+                    if (match && match[0].length > 2 && (slashes = match[0].length, state.index += slashes, slashes % 2 != 0 && (value += '\\')), !0 === opts.unescape ? value = advance() : value += advance(), 0 === state.brackets) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                }
+                if (state.brackets > 0 && (']' !== value || '[' === prev.value || '[^' === prev.value)) {
+                    if (!1 !== opts.posix && ':' === value) {
+                        let inner = prev.value.slice(1);
+                        if (inner.includes('[') && (prev.posix = !0, inner.includes(':'))) {
+                            let idx = prev.value.lastIndexOf('['), pre = prev.value.slice(0, idx), posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+                            if (posix) {
+                                prev.value = pre + posix, state.backtrack = !0, advance(), bos.output || 1 !== tokens.indexOf(prev) || (bos.output = ONE_CHAR);
+                                continue;
+                            }
+                        }
+                    }
+                    ('[' === value && ':' !== peek() || '-' === value && ']' === peek()) && (value = `\\${value}`), ']' === value && ('[' === prev.value || '[^' === prev.value) && (value = `\\${value}`), !0 === opts.posix && '!' === value && '[' === prev.value && (value = '^'), prev.value += value, append({
+                        value
+                    });
+                    continue;
+                }
+                if (1 === state.quotes && '"' !== value) {
+                    value = utils.escapeRegex(value), prev.value += value, append({
+                        value
+                    });
+                    continue;
+                }
+                if ('"' === value) {
+                    state.quotes = +(1 !== state.quotes), !0 === opts.keepQuotes && push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('(' === value) {
+                    increment('parens'), push({
+                        type: 'paren',
+                        value
+                    });
+                    continue;
+                }
+                if (')' === value) {
+                    if (0 === state.parens && !0 === opts.strictBrackets) throw SyntaxError(syntaxError('opening', '('));
+                    let extglob = extglobs[extglobs.length - 1];
+                    if (extglob && state.parens === extglob.parens + 1) {
+                        extglobClose(extglobs.pop());
+                        continue;
+                    }
+                    push({
+                        type: 'paren',
+                        value,
+                        output: state.parens ? ')' : '\\)'
+                    }), decrement('parens');
+                    continue;
+                }
+                if ('[' === value) {
+                    if (!0 !== opts.nobracket && remaining().includes(']')) increment('brackets');
+                    else {
+                        if (!0 !== opts.nobracket && !0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', ']'));
+                        value = `\\${value}`;
+                    }
+                    push({
+                        type: 'bracket',
+                        value
+                    });
+                    continue;
+                }
+                if (']' === value) {
+                    if (!0 === opts.nobracket || prev && 'bracket' === prev.type && 1 === prev.value.length) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    if (0 === state.brackets) {
+                        if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('opening', '['));
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    decrement('brackets');
+                    let prevValue = prev.value.slice(1);
+                    if (!0 === prev.posix || '^' !== prevValue[0] || prevValue.includes('/') || (value = `/${value}`), prev.value += value, append({
+                        value
+                    }), !1 === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    let escaped = utils.escapeRegex(prev.value);
+                    if (state.output = state.output.slice(0, -prev.value.length), !0 === opts.literalBrackets) {
+                        state.output += escaped, prev.value = escaped;
+                        continue;
+                    }
+                    prev.value = `(${capture}${escaped}|${prev.value})`, state.output += prev.value;
+                    continue;
+                }
+                if ('{' === value && !0 !== opts.nobrace) {
+                    increment('braces');
+                    let open = {
+                        type: 'brace',
+                        value,
+                        output: '(',
+                        outputIndex: state.output.length,
+                        tokensIndex: state.tokens.length
+                    };
+                    braces.push(open), push(open);
+                    continue;
+                }
+                if ('}' === value) {
+                    let brace = braces[braces.length - 1];
+                    if (!0 === opts.nobrace || !brace) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: value
+                        });
+                        continue;
+                    }
+                    let output = ')';
+                    if (!0 === brace.dots) {
+                        let arr = tokens.slice(), range = [];
+                        for(let i = arr.length - 1; i >= 0 && (tokens.pop(), 'brace' !== arr[i].type); i--)'dots' !== arr[i].type && range.unshift(arr[i].value);
+                        output = expandRange(range, opts), state.backtrack = !0;
+                    }
+                    if (!0 !== brace.comma && !0 !== brace.dots) {
+                        let out = state.output.slice(0, brace.outputIndex), toks = state.tokens.slice(brace.tokensIndex);
+                        for (let t of (brace.value = brace.output = '\\{', value = output = '\\}', state.output = out, toks))state.output += t.output || t.value;
+                    }
+                    push({
+                        type: 'brace',
+                        value,
+                        output
+                    }), decrement('braces'), braces.pop();
+                    continue;
+                }
+                if ('|' === value) {
+                    extglobs.length > 0 && extglobs[extglobs.length - 1].conditions++, push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (',' === value) {
+                    let output = value, brace = braces[braces.length - 1];
+                    brace && 'braces' === stack[stack.length - 1] && (brace.comma = !0, output = '|'), push({
+                        type: 'comma',
+                        value,
+                        output
+                    });
+                    continue;
+                }
+                if ('/' === value) {
+                    if ('dot' === prev.type && state.index === state.start + 1) {
+                        state.start = state.index + 1, state.consumed = '', state.output = '', tokens.pop(), prev = bos;
+                        continue;
+                    }
+                    push({
+                        type: 'slash',
+                        value,
+                        output: SLASH_LITERAL
+                    });
+                    continue;
+                }
+                if ('.' === value) {
+                    if (state.braces > 0 && 'dot' === prev.type) {
+                        '.' === prev.value && (prev.output = DOT_LITERAL);
+                        let brace = braces[braces.length - 1];
+                        prev.type = 'dots', prev.output += value, prev.value += value, brace.dots = !0;
+                        continue;
+                    }
+                    if (state.braces + state.parens === 0 && 'bos' !== prev.type && 'slash' !== prev.type) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: DOT_LITERAL
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value,
+                        output: DOT_LITERAL
+                    });
+                    continue;
+                }
+                if ('?' === value) {
+                    if (!(prev && '(' === prev.value) && !0 !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('qmark', value);
+                        continue;
+                    }
+                    if (prev && 'paren' === prev.type) {
+                        let next = peek(), output = value;
+                        ('(' !== prev.value || /[!=<:]/.test(next)) && ('<' !== next || /<([!=]|\w+>)/.test(remaining())) || (output = `\\${value}`), push({
+                            type: 'text',
+                            value,
+                            output
+                        });
+                        continue;
+                    }
+                    if (!0 !== opts.dot && ('slash' === prev.type || 'bos' === prev.type)) {
+                        push({
+                            type: 'qmark',
+                            value,
+                            output: QMARK_NO_DOT
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'qmark',
+                        value,
+                        output: QMARK
+                    });
+                    continue;
+                }
+                if ('!' === value) {
+                    if (!0 !== opts.noextglob && '(' === peek() && ('?' !== peek(2) || !/[!=<:]/.test(peek(3)))) {
+                        extglobOpen('negate', value);
+                        continue;
+                    }
+                    if (!0 !== opts.nonegate && 0 === state.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ('+' === value) {
+                    if (!0 !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('plus', value);
+                        continue;
+                    }
+                    if (prev && '(' === prev.value || !1 === opts.regex) {
+                        push({
+                            type: 'plus',
+                            value,
+                            output: PLUS_LITERAL
+                        });
+                        continue;
+                    }
+                    if (prev && ('bracket' === prev.type || 'paren' === prev.type || 'brace' === prev.type) || state.parens > 0) {
+                        push({
+                            type: 'plus',
+                            value
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'plus',
+                        value: PLUS_LITERAL
+                    });
+                    continue;
+                }
+                if ('@' === value) {
+                    if (!0 !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: !0,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('*' !== value) {
+                    ('$' === value || '^' === value) && (value = `\\${value}`);
+                    let match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+                    match && (value += match[0], state.index += match[0].length), push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (prev && ('globstar' === prev.type || !0 === prev.star)) {
+                    prev.type = 'star', prev.star = !0, prev.value += value, prev.output = star, state.backtrack = !0, state.globstar = !0, consume(value);
+                    continue;
+                }
+                let rest = remaining();
+                if (!0 !== opts.noextglob && /^\([^?]/.test(rest)) {
+                    extglobOpen('star', value);
+                    continue;
+                }
+                if ('star' === prev.type) {
+                    if (!0 === opts.noglobstar) {
+                        consume(value);
+                        continue;
+                    }
+                    let prior = prev.prev, before = prior.prev, isStart = 'slash' === prior.type || 'bos' === prior.type, afterStar = before && ('star' === before.type || 'globstar' === before.type);
+                    if (!0 === opts.bash && (!isStart || rest[0] && '/' !== rest[0])) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    let isBrace = state.braces > 0 && ('comma' === prior.type || 'brace' === prior.type), isExtglob = extglobs.length && ('pipe' === prior.type || 'paren' === prior.type);
+                    if (!isStart && 'paren' !== prior.type && !isBrace && !isExtglob) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    for(; '/**' === rest.slice(0, 3);){
+                        let after = input[state.index + 4];
+                        if (after && '/' !== after) break;
+                        rest = rest.slice(3), consume('/**', 3);
+                    }
+                    if ('bos' === prior.type && eos()) {
+                        prev.type = 'globstar', prev.value += value, prev.output = globstar(opts), state.output = prev.output, state.globstar = !0, consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && !afterStar && eos()) {
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length), prior.output = `(?:${prior.output}`, prev.type = 'globstar', prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)'), prev.value += value, state.globstar = !0, state.output += prior.output + prev.output, consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && '/' === rest[0]) {
+                        let end = void 0 !== rest[1] ? '|$' : '';
+                        state.output = state.output.slice(0, -(prior.output + prev.output).length), prior.output = `(?:${prior.output}`, prev.type = 'globstar', prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`, prev.value += value, state.output += prior.output + prev.output, state.globstar = !0, consume(value + advance()), push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    if ('bos' === prior.type && '/' === rest[0]) {
+                        prev.type = 'globstar', prev.value += value, prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`, state.output = prev.output, state.globstar = !0, consume(value + advance()), push({
+                            type: 'slash',
+                            value: '/',
+                            output: ''
+                        });
+                        continue;
+                    }
+                    state.output = state.output.slice(0, -prev.output.length), prev.type = 'globstar', prev.output = globstar(opts), prev.value += value, state.output += prev.output, state.globstar = !0, consume(value);
+                    continue;
+                }
+                let token = {
+                    type: 'star',
+                    value,
+                    output: star
+                };
+                if (!0 === opts.bash) {
+                    token.output = '.*?', ('bos' === prev.type || 'slash' === prev.type) && (token.output = nodot + token.output), push(token);
+                    continue;
+                }
+                if (prev && ('bracket' === prev.type || 'paren' === prev.type) && !0 === opts.regex) {
+                    token.output = value, push(token);
+                    continue;
+                }
+                (state.index === state.start || 'slash' === prev.type || 'dot' === prev.type) && ('dot' === prev.type ? (state.output += NO_DOT_SLASH, prev.output += NO_DOT_SLASH) : !0 === opts.dot ? (state.output += NO_DOTS_SLASH, prev.output += NO_DOTS_SLASH) : (state.output += nodot, prev.output += nodot), '*' !== peek() && (state.output += ONE_CHAR, prev.output += ONE_CHAR)), push(token);
+            }
+            for(; state.brackets > 0;){
+                if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', ']'));
+                state.output = utils.escapeLast(state.output, '['), decrement('brackets');
+            }
+            for(; state.parens > 0;){
+                if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', ')'));
+                state.output = utils.escapeLast(state.output, '('), decrement('parens');
+            }
+            for(; state.braces > 0;){
+                if (!0 === opts.strictBrackets) throw SyntaxError(syntaxError('closing', '}'));
+                state.output = utils.escapeLast(state.output, '{'), decrement('braces');
+            }
+            if (!0 !== opts.strictSlashes && ('star' === prev.type || 'bracket' === prev.type) && push({
+                type: 'maybe_slash',
+                value: '',
+                output: `${SLASH_LITERAL}?`
+            }), !0 === state.backtrack) for (let token of (state.output = '', state.tokens))state.output += null != token.output ? token.output : token.value, token.suffix && (state.output += token.suffix);
+            return state;
+        };
+        parse.fastpaths = (input, options)=>{
+            let opts = {
+                ...options
+            }, max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH, len = input.length;
+            if (len > max) throw SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            input = REPLACEMENTS[input] || input;
+            let { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows), nodot = opts.dot ? NO_DOTS : NO_DOT, slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT, capture = opts.capture ? '' : '?:', star = !0 === opts.bash ? '.*?' : STAR;
+            opts.capture && (star = `(${star})`);
+            let globstar = (opts)=>!0 === opts.noglobstar ? star : `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`, create = (str)=>{
+                switch(str){
+                    case '*':
+                        return `${nodot}${ONE_CHAR}${star}`;
+                    case '.*':
+                        return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*.*':
+                        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '*/*':
+                        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+                    case '**':
+                        return nodot + globstar(opts);
+                    case '**/*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+                    case '**/*.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    case '**/.*':
+                        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+                    default:
+                        {
+                            let match = /^(.*?)\.(\w+)$/.exec(str);
+                            if (!match) return;
+                            let source = create(match[1]);
+                            if (!source) return;
+                            return source + DOT_LITERAL + match[2];
+                        }
+                }
+            }, source = create(utils.removePrefix(input, {
+                negated: !1,
+                prefix: ''
+            }));
+            return source && !0 !== opts.strictSlashes && (source += `${SLASH_LITERAL}?`), source;
+        }, module.exports = parse;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let scan = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js"), parse = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/parse.js"), utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js"), constants = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js"), picomatch = (glob, options, returnState = !1)=>{
+            if (Array.isArray(glob)) {
+                let fns = glob.map((input)=>picomatch(input, options, returnState));
+                return (str)=>{
+                    for (let isMatch of fns){
+                        let state = isMatch(str);
+                        if (state) return state;
+                    }
+                    return !1;
+                };
+            }
+            let isState = glob && 'object' == typeof glob && !Array.isArray(glob) && glob.tokens && glob.input;
+            if ('' === glob || 'string' != typeof glob && !isState) throw TypeError('Expected pattern to be a non-empty string');
+            let opts = options || {}, posix = opts.windows, regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, !1, !0), state = regex.state;
+            delete regex.state;
+            let isIgnored = ()=>!1;
+            if (opts.ignore) {
+                let ignoreOpts = {
+                    ...options,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+            }
+            let matcher = (input, returnObject = !1)=>{
+                let { isMatch, match, output } = picomatch.test(input, regex, options, {
+                    glob,
+                    posix
+                }), result = {
+                    glob,
+                    state,
+                    regex,
+                    posix,
+                    input,
+                    output,
+                    match,
+                    isMatch
+                };
+                return ('function' == typeof opts.onResult && opts.onResult(result), !1 === isMatch) ? (result.isMatch = !1, !!returnObject && result) : isIgnored(input) ? ('function' == typeof opts.onIgnore && opts.onIgnore(result), result.isMatch = !1, !!returnObject && result) : ('function' == typeof opts.onMatch && opts.onMatch(result), !returnObject || result);
+            };
+            return returnState && (matcher.state = state), matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {})=>{
+            if ('string' != typeof input) throw TypeError('Expected input to be a string');
+            if ('' === input) return {
+                isMatch: !1,
+                output: ''
+            };
+            let opts = options || {}, format = opts.format || (posix ? utils.toPosixSlashes : null), match = input === glob, output = match && format ? format(input) : input;
+            return !1 === match && (match = (output = format ? format(input) : input) === glob), (!1 === match || !0 === opts.capture) && (match = !0 === opts.matchBase || !0 === opts.basename ? picomatch.matchBase(input, regex, options, posix) : regex.exec(output)), {
+                isMatch: !!match,
+                match,
+                output
+            };
+        }, picomatch.matchBase = (input, glob, options)=>(glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input)), picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str), picomatch.parse = (pattern, options)=>Array.isArray(pattern) ? pattern.map((p)=>picomatch.parse(p, options)) : parse(pattern, {
+                ...options,
+                fastpaths: !1
+            }), picomatch.scan = (input, options)=>scan(input, options), picomatch.compileRe = (state, options, returnOutput = !1, returnState = !1)=>{
+            if (!0 === returnOutput) return state.output;
+            let opts = options || {}, prepend = opts.contains ? '' : '^', append = opts.contains ? '' : '$', source = `${prepend}(?:${state.output})${append}`;
+            state && !0 === state.negated && (source = `^(?!${source}).*$`);
+            let regex = picomatch.toRegex(source, options);
+            return !0 === returnState && (regex.state = state), regex;
+        }, picomatch.makeRe = (input, options = {}, returnOutput = !1, returnState = !1)=>{
+            if (!input || 'string' != typeof input) throw TypeError('Expected a non-empty string');
+            let parsed = {
+                negated: !1,
+                fastpaths: !0
+            };
+            return !1 !== options.fastpaths && ('.' === input[0] || '*' === input[0]) && (parsed.output = parse.fastpaths(input, options)), parsed.output || (parsed = parse(input, options)), picomatch.compileRe(parsed, options, returnOutput, returnState);
+        }, picomatch.toRegex = (source, options)=>{
+            try {
+                let opts = options || {};
+                return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+            } catch (err) {
+                if (options && !0 === options.debug) throw err;
+                return /$^/;
+            }
+        }, picomatch.constants = constants, module.exports = picomatch;
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/scan.js" (module, __unused_rspack_exports, __webpack_require__) {
+        let utils = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js"), { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js"), isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH, depth = (token)=>{
+            !0 !== token.isPrefix && (token.depth = token.isGlobstar ? 1 / 0 : 1);
+        };
+        module.exports = (input, options)=>{
+            let prev, code, opts = options || {}, length = input.length - 1, scanToEnd = !0 === opts.parts || !0 === opts.scanToEnd, slashes = [], tokens = [], parts = [], str = input, index = -1, start = 0, lastIndex = 0, isBrace = !1, isBracket = !1, isGlob = !1, isExtglob = !1, isGlobstar = !1, braceEscaped = !1, backslashes = !1, negated = !1, negatedExtglob = !1, finished = !1, braces = 0, token = {
+                value: '',
+                depth: 0,
+                isGlob: !1
+            }, eos = ()=>index >= length, peek = ()=>str.charCodeAt(index + 1), advance = ()=>(prev = code, str.charCodeAt(++index));
+            for(; index < length;){
+                let next;
+                if ((code = advance()) === CHAR_BACKWARD_SLASH) {
+                    backslashes = token.backslashes = !0, (code = advance()) === CHAR_LEFT_CURLY_BRACE && (braceEscaped = !0);
+                    continue;
+                }
+                if (!0 === braceEscaped || code === CHAR_LEFT_CURLY_BRACE) {
+                    for(braces++; !0 !== eos() && (code = advance());){
+                        if (code === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = !0, advance();
+                            continue;
+                        }
+                        if (code === CHAR_LEFT_CURLY_BRACE) {
+                            braces++;
+                            continue;
+                        }
+                        if (!0 !== braceEscaped && code === CHAR_DOT && (code = advance()) === CHAR_DOT || !0 !== braceEscaped && code === CHAR_COMMA) {
+                            if (isBrace = token.isBrace = !0, isGlob = token.isGlob = !0, finished = !0, !0 === scanToEnd) continue;
+                            break;
+                        }
+                        if (code === CHAR_RIGHT_CURLY_BRACE && 0 == --braces) {
+                            braceEscaped = !1, isBrace = token.isBrace = !0, finished = !0;
+                            break;
+                        }
+                    }
+                    if (!0 === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_FORWARD_SLASH) {
+                    if (slashes.push(index), tokens.push(token), token = {
+                        value: '',
+                        depth: 0,
+                        isGlob: !1
+                    }, !0 === finished) continue;
+                    if (prev === CHAR_DOT && index === start + 1) {
+                        start += 2;
+                        continue;
+                    }
+                    lastIndex = index + 1;
+                    continue;
+                }
+                if (!0 !== opts.noext && !0 == (code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) && peek() === CHAR_LEFT_PARENTHESES) {
+                    if (isGlob = token.isGlob = !0, isExtglob = token.isExtglob = !0, finished = !0, code === CHAR_EXCLAMATION_MARK && index === start && (negatedExtglob = !0), !0 === scanToEnd) {
+                        for(; !0 !== eos() && (code = advance());){
+                            if (code === CHAR_BACKWARD_SLASH) {
+                                backslashes = token.backslashes = !0, code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                isGlob = token.isGlob = !0, finished = !0;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (code === CHAR_ASTERISK) {
+                    if (prev === CHAR_ASTERISK && (isGlobstar = token.isGlobstar = !0), isGlob = token.isGlob = !0, finished = !0, !0 === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_QUESTION_MARK) {
+                    if (isGlob = token.isGlob = !0, finished = !0, !0 === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_LEFT_SQUARE_BRACKET) {
+                    for(; !0 !== eos() && (next = advance());){
+                        if (next === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = !0, advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            isBracket = token.isBracket = !0, isGlob = token.isGlob = !0, finished = !0;
+                            break;
+                        }
+                    }
+                    if (!0 === scanToEnd) continue;
+                    break;
+                }
+                if (!0 !== opts.nonegate && code === CHAR_EXCLAMATION_MARK && index === start) {
+                    negated = token.negated = !0, start++;
+                    continue;
+                }
+                if (!0 !== opts.noparen && code === CHAR_LEFT_PARENTHESES) {
+                    if (isGlob = token.isGlob = !0, !0 === scanToEnd) {
+                        for(; !0 !== eos() && (code = advance());){
+                            if (code === CHAR_LEFT_PARENTHESES) {
+                                backslashes = token.backslashes = !0, code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                finished = !0;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (!0 === isGlob) {
+                    if (finished = !0, !0 === scanToEnd) continue;
+                    break;
+                }
+            }
+            !0 === opts.noext && (isExtglob = !1, isGlob = !1);
+            let base = str, prefix = '', glob = '';
+            start > 0 && (prefix = str.slice(0, start), str = str.slice(start), lastIndex -= start), base && !0 === isGlob && lastIndex > 0 ? (base = str.slice(0, lastIndex), glob = str.slice(lastIndex)) : !0 === isGlob ? (base = '', glob = str) : base = str, base && '' !== base && '/' !== base && base !== str && isPathSeparator(base.charCodeAt(base.length - 1)) && (base = base.slice(0, -1)), !0 === opts.unescape && (glob && (glob = utils.removeBackslashes(glob)), base && !0 === backslashes && (base = utils.removeBackslashes(base)));
+            let state = {
+                prefix,
+                input,
+                start,
+                base,
+                glob,
+                isBrace,
+                isBracket,
+                isGlob,
+                isExtglob,
+                isGlobstar,
+                negated,
+                negatedExtglob
+            };
+            if (!0 === opts.tokens && (state.maxDepth = 0, isPathSeparator(code) || tokens.push(token), state.tokens = tokens), !0 === opts.parts || !0 === opts.tokens) {
+                let prevIndex;
+                for(let idx = 0; idx < slashes.length; idx++){
+                    let n = prevIndex ? prevIndex + 1 : start, i = slashes[idx], value = input.slice(n, i);
+                    opts.tokens && (0 === idx && 0 !== start ? (tokens[idx].isPrefix = !0, tokens[idx].value = prefix) : tokens[idx].value = value, depth(tokens[idx]), state.maxDepth += tokens[idx].depth), (0 !== idx || '' !== value) && parts.push(value), prevIndex = i;
+                }
+                if (prevIndex && prevIndex + 1 < input.length) {
+                    let value = input.slice(prevIndex + 1);
+                    parts.push(value), opts.tokens && (tokens[tokens.length - 1].value = value, depth(tokens[tokens.length - 1]), state.maxDepth += tokens[tokens.length - 1].depth);
+                }
+                state.slashes = slashes, state.parts = parts;
+            }
+            return state;
+        };
+    },
+    "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        let { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/constants.js");
+        exports.isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val), exports.hasRegexChars = (str)=>REGEX_SPECIAL_CHARS.test(str), exports.isRegexChar = (str)=>1 === str.length && exports.hasRegexChars(str), exports.escapeRegex = (str)=>str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1'), exports.toPosixSlashes = (str)=>str.replace(REGEX_BACKSLASH, '/'), exports.isWindows = ()=>{
+            if ("u" > typeof navigator && navigator.platform) {
+                let platform = navigator.platform.toLowerCase();
+                return 'win32' === platform || 'windows' === platform;
+            }
+            return "u" > typeof process && !!process.platform && 'win32' === process.platform;
+        }, exports.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match), exports.escapeLast = (input, char, lastIdx)=>{
+            let idx = input.lastIndexOf(char, lastIdx);
+            return -1 === idx ? input : '\\' === input[idx - 1] ? exports.escapeLast(input, char, idx - 1) : `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        }, exports.removePrefix = (input, state = {})=>{
+            let output = input;
+            return output.startsWith('./') && (output = output.slice(2), state.prefix = './'), output;
+        }, exports.wrapOutput = (input, state = {}, options = {})=>{
+            let prepend = options.contains ? '' : '^', append = options.contains ? '' : '$', output = `${prepend}(?:${input})${append}`;
+            return !0 === state.negated && (output = `(?:^(?!${output}).*$)`), output;
+        }, exports.basename = (path, { windows } = {})=>{
+            let segs = path.split(windows ? /[\\/]/ : '/'), last = segs[segs.length - 1];
+            return '' === last ? segs[segs.length - 2] : last;
+        };
+    },
     "../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         let valueOf = Symbol.prototype.valueOf, typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
         module.exports = function(val, deep) {
@@ -1129,39 +2112,394 @@ __webpack_require__.add({
         module.exports = __rspack_external_url;
     }
 });
-let isCI = !!process.env.CI, isTTY = !!process.stdout?.isTTY, noColor = !!process.env.NO_COLOR, forceColor = !!process.env.FORCE_COLOR, disableColor = !1;
-disableColor = !!noColor || !forceColor && (isCI || !isTTY);
-let ANSI_SGR_RE = /\x1b\[[0-9;]*m/g, ANSI_OPEN_RE = /\x1b\[([0-9;]+)m/g, COLOR_HEX = {
-    brand: '#B39AFF',
-    red: '#F38BA8',
-    green: '#A6E3A1',
-    yellow: '#F9E2AF',
-    blue: '#89B4FA',
-    magenta: '#EE90DB',
-    cyan: '#89DCEB',
-    gray: '#6C7086'
-}, COLOR_HEX_TO_OPEN = Object.fromEntries(Object.values(COLOR_HEX).map((hex)=>[
-        hex,
-        ((hex)=>{
-            let r, g, b, value = (hex || '').trim().replace(/^#/, '');
-            if (/^[0-9a-fA-F]{3}$/.test(value)) r = Number.parseInt(value[0] + value[0], 16), g = Number.parseInt(value[1] + value[1], 16), b = Number.parseInt(value[2] + value[2], 16);
-            else {
-                if (!/^[0-9a-fA-F]{6}$/.test(value)) return '';
-                r = Number.parseInt(value.slice(0, 2), 16), g = Number.parseInt(value.slice(2, 4), 16), b = Number.parseInt(value.slice(4, 6), 16);
+var LogColor, CACError = class extends Error {
+    constructor(message){
+        super(message), this.name = "CACError", "function" != typeof Error.captureStackTrace && (this.stack = Error(message).stack);
+    }
+}, Option = class {
+    rawName;
+    description;
+    name;
+    names;
+    isBoolean;
+    required;
+    config;
+    negated;
+    constructor(rawName, description, config){
+        this.rawName = rawName, this.description = description, this.config = Object.assign({}, config), rawName = rawName.replaceAll(".*", ""), this.negated = !1, this.names = removeBrackets(rawName).split(",").map((v)=>{
+            let name = v.trim().replace(/^-{1,2}/, "");
+            return name.startsWith("no-") && (this.negated = !0, name = name.replace(/^no-/, "")), camelcaseOptionName(name);
+        }).sort((a, b)=>a.length > b.length ? 1 : -1), this.name = this.names.at(-1), this.negated && null == this.config.default && (this.config.default = !0), rawName.includes("<") ? this.required = !0 : rawName.includes("[") ? this.required = !1 : this.isBoolean = !0;
+    }
+};
+if ("u" > typeof process) {
+    let runtimeName;
+    runtimeName = "u" > typeof Deno && "string" == typeof Deno.version?.deno ? "deno" : "u" > typeof Bun && "string" == typeof Bun.version ? "bun" : "node", runtimeInfo = `${process.platform}-${process.arch} ${runtimeName}-${process.version}`, runtimeProcessArgs = process.argv;
+} else runtimeInfo = "u" < typeof navigator ? "unknown" : `${navigator.platform} ${navigator.userAgent}`;
+var Command = class {
+    rawName;
+    description;
+    config;
+    cli;
+    options;
+    aliasNames;
+    name;
+    args;
+    commandAction;
+    usageText;
+    versionNumber;
+    examples;
+    helpCallback;
+    globalCommand;
+    constructor(rawName, description, config = {}, cli){
+        this.rawName = rawName, this.description = description, this.config = config, this.cli = cli, this.options = [], this.aliasNames = [], this.name = removeBrackets(rawName), this.args = function(v) {
+            let angledMatch, squareMatch, ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g, SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g, res = [], parse = (match)=>{
+                let variadic = !1, value = match[1];
+                return value.startsWith("...") && (value = value.slice(3), variadic = !0), {
+                    required: match[0].startsWith("<"),
+                    value,
+                    variadic
+                };
+            };
+            for(; angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v);)res.push(parse(angledMatch));
+            for(; squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v);)res.push(parse(squareMatch));
+            return res;
+        }(rawName), this.examples = [];
+    }
+    usage(text) {
+        return this.usageText = text, this;
+    }
+    allowUnknownOptions() {
+        return this.config.allowUnknownOptions = !0, this;
+    }
+    ignoreOptionDefaultValue() {
+        return this.config.ignoreOptionDefaultValue = !0, this;
+    }
+    version(version, customFlags = "-v, --version") {
+        return this.versionNumber = version, this.option(customFlags, "Display version number"), this;
+    }
+    example(example) {
+        return this.examples.push(example), this;
+    }
+    option(rawName, description, config) {
+        let option = new Option(rawName, description, config);
+        return this.options.push(option), this;
+    }
+    alias(name) {
+        return this.aliasNames.push(name), this;
+    }
+    action(callback) {
+        return this.commandAction = callback, this;
+    }
+    isMatched(name) {
+        return this.name === name || this.aliasNames.includes(name);
+    }
+    get isDefaultCommand() {
+        return "" === this.name || this.aliasNames.includes("!");
+    }
+    get isGlobalCommand() {
+        return this instanceof GlobalCommand;
+    }
+    hasOption(name) {
+        return name = name.split(".")[0], this.options.find((option)=>option.names.includes(name));
+    }
+    outputHelp() {
+        let { name, commands } = this.cli, { versionNumber, options: globalOptions, helpCallback } = this.cli.globalCommand, sections = [
+            {
+                body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
             }
-            return `\x1b[38;2;${r};${g};${b}m`;
-        })(hex)
-    ])), hexColor = (hex)=>{
-    if (disableColor) return (input)=>String(input);
-    let open = COLOR_HEX_TO_OPEN[hex];
-    return open ? (input)=>`${open}${input}\x1b[39m` : (input)=>String(input);
-}, ansi = (open, close)=>(input)=>disableColor ? String(input) : `${open}${input}${close}`, colors = {
-    brand: hexColor(COLOR_HEX.brand),
-    red: hexColor(COLOR_HEX.red),
-    green: hexColor(COLOR_HEX.green),
-    yellow: hexColor(COLOR_HEX.yellow),
-    blue: hexColor(COLOR_HEX.blue),
-    magenta: hexColor(COLOR_HEX.magenta),
+        ];
+        if (sections.push({
+            title: "Usage",
+            body: `  $ ${name} ${this.usageText || this.rawName}`
+        }), (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
+            let longestCommandName = findLongest(commands.map((command)=>command.rawName));
+            sections.push({
+                title: "Commands",
+                body: commands.map((command)=>`  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`).join("\n")
+            }, {
+                title: "For more info, run any command with the `--help` flag",
+                body: commands.map((command)=>`  $ ${name}${"" === command.name ? "" : ` ${command.name}`} --help`).join("\n")
+            });
+        }
+        let options = this.isGlobalCommand ? globalOptions : [
+            ...this.options,
+            ...globalOptions || []
+        ];
+        if (this.isGlobalCommand || this.isDefaultCommand || (options = options.filter((option)=>"version" !== option.name)), options.length > 0) {
+            let longestOptionName = findLongest(options.map((option)=>option.rawName));
+            sections.push({
+                title: "Options",
+                body: options.map((option)=>`  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${void 0 === option.config.default ? "" : `(default: ${option.config.default})`}`).join("\n")
+            });
+        }
+        this.examples.length > 0 && sections.push({
+            title: "Examples",
+            body: this.examples.map((example)=>"function" == typeof example ? example(name) : example).join("\n")
+        }), helpCallback && (sections = helpCallback(sections) || sections), console.info(sections.map((section)=>section.title ? `${section.title}:\n${section.body}` : section.body).join("\n\n"));
+    }
+    outputVersion() {
+        let { name } = this.cli, { versionNumber } = this.cli.globalCommand;
+        versionNumber && console.info(`${name}/${versionNumber} ${runtimeInfo}`);
+    }
+    checkRequiredArgs() {
+        let minimalArgsCount = this.args.filter((arg)=>arg.required).length;
+        if (this.cli.args.length < minimalArgsCount) throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+    checkUnknownOptions() {
+        let { options, globalCommand } = this.cli;
+        if (!this.config.allowUnknownOptions) {
+            for (let name of Object.keys(options))if ("--" !== name && !this.hasOption(name) && !globalCommand.hasOption(name)) throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+    }
+    checkOptionValue() {
+        let { options: parsedOptions, globalCommand } = this.cli, options = [
+            ...globalCommand.options,
+            ...this.options
+        ];
+        for (let option of options){
+            let value = parsedOptions[option.name.split(".")[0]];
+            if (option.required) {
+                let hasNegated = options.some((o)=>o.negated && o.names.includes(option.name));
+                if (!0 === value || !1 === value && !hasNegated) throw new CACError(`option \`${option.rawName}\` value is missing`);
+            }
+        }
+    }
+    checkUnusedArgs() {
+        let maximumArgsCount = this.args.some((arg)=>arg.variadic) ? 1 / 0 : this.args.length;
+        if (maximumArgsCount < this.cli.args.length) throw new CACError(`Unused args: ${this.cli.args.slice(maximumArgsCount).map((arg)=>`\`${arg}\``).join(", ")}`);
+    }
+}, GlobalCommand = class extends Command {
+    constructor(cli){
+        super("@@global@@", "", {}, cli);
+    }
+}, CAC = class extends EventTarget {
+    name;
+    commands;
+    globalCommand;
+    matchedCommand;
+    matchedCommandName;
+    rawArgs;
+    args;
+    options;
+    showHelpOnExit;
+    showVersionOnExit;
+    constructor(name = ""){
+        super(), this.name = name, this.commands = [], this.rawArgs = [], this.args = [], this.options = {}, this.globalCommand = new GlobalCommand(this), this.globalCommand.usage("<command> [options]");
+    }
+    usage(text) {
+        return this.globalCommand.usage(text), this;
+    }
+    command(rawName, description, config) {
+        let command = new Command(rawName, description || "", config, this);
+        return command.globalCommand = this.globalCommand, this.commands.push(command), command;
+    }
+    option(rawName, description, config) {
+        return this.globalCommand.option(rawName, description, config), this;
+    }
+    help(callback) {
+        return this.globalCommand.option("-h, --help", "Display this message"), this.globalCommand.helpCallback = callback, this.showHelpOnExit = !0, this;
+    }
+    version(version, customFlags = "-v, --version") {
+        return this.globalCommand.version(version, customFlags), this.showVersionOnExit = !0, this;
+    }
+    example(example) {
+        return this.globalCommand.example(example), this;
+    }
+    outputHelp() {
+        this.matchedCommand ? this.matchedCommand.outputHelp() : this.globalCommand.outputHelp();
+    }
+    outputVersion() {
+        this.globalCommand.outputVersion();
+    }
+    setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+        return this.args = args, this.options = options, matchedCommand && (this.matchedCommand = matchedCommand), matchedCommandName && (this.matchedCommandName = matchedCommandName), this;
+    }
+    unsetMatchedCommand() {
+        this.matchedCommand = void 0, this.matchedCommandName = void 0;
+    }
+    parse(argv, { run = !0 } = {}) {
+        var input;
+        let m;
+        if (!argv) {
+            if (!runtimeProcessArgs) throw Error("No argv provided and runtime process argv is not available.");
+            argv = runtimeProcessArgs;
+        }
+        this.rawArgs = argv, this.name || (this.name = argv[1] ? (input = argv[1], (m = /([^\\/]+)$/.exec(input)) ? m[1] : "") : "cli");
+        let shouldParse = !0;
+        for (let command of this.commands){
+            let parsed = this.mri(argv.slice(2), command), commandName = parsed.args[0];
+            if (command.isMatched(commandName)) {
+                shouldParse = !1;
+                let parsedInfo = {
+                    ...parsed,
+                    args: parsed.args.slice(1)
+                };
+                this.setParsedInfo(parsedInfo, command, commandName), this.dispatchEvent(new CustomEvent(`command:${commandName}`, {
+                    detail: command
+                }));
+            }
+        }
+        if (shouldParse) {
+            for (let command of this.commands)if (command.isDefaultCommand) {
+                shouldParse = !1;
+                let parsed = this.mri(argv.slice(2), command);
+                this.setParsedInfo(parsed, command), this.dispatchEvent(new CustomEvent("command:!", {
+                    detail: command
+                }));
+            }
+        }
+        if (shouldParse) {
+            let parsed = this.mri(argv.slice(2));
+            this.setParsedInfo(parsed);
+        }
+        this.options.help && this.showHelpOnExit && (this.outputHelp(), run = !1, this.unsetMatchedCommand()), this.options.version && this.showVersionOnExit && null == this.matchedCommandName && (this.outputVersion(), run = !1, this.unsetMatchedCommand());
+        let parsedArgv = {
+            args: this.args,
+            options: this.options
+        };
+        return run && this.runMatchedCommand(), !this.matchedCommand && this.args[0] && this.dispatchEvent(new CustomEvent("command:*", {
+            detail: this.args[0]
+        })), parsedArgv;
+    }
+    mri(argv, command) {
+        let cliOptions = [
+            ...this.globalCommand.options,
+            ...command ? command.options : []
+        ], mriOptions = function(options) {
+            let result = {
+                alias: {},
+                boolean: []
+            };
+            for (let [index, option] of options.entries())option.names.length > 1 && (result.alias[option.names[0]] = option.names.slice(1)), option.isBoolean && (option.negated && options.some((o, i)=>i !== index && o.names.some((name)=>option.names.includes(name)) && "boolean" == typeof o.required) || result.boolean.push(option.names[0]));
+            return result;
+        }(cliOptions), argsAfterDoubleDashes = [], doubleDashesIndex = argv.indexOf("--");
+        -1 !== doubleDashesIndex && (argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1), argv = argv.slice(0, doubleDashesIndex));
+        let parsed = function(args, opts) {
+            opts = opts || {};
+            var k, arr, arg, name, val, out = {
+                _: []
+            }, i = 0, j = 0, idx = 0, len = (args = args || []).length;
+            let alibi = void 0 !== opts.alias, strict = void 0 !== opts.unknown, defaults = void 0 !== opts.default;
+            if (opts.alias = opts.alias || {}, opts.string = toArr(opts.string), opts.boolean = toArr(opts.boolean), alibi) for(k in opts.alias)for(i = 0, arr = opts.alias[k] = toArr(opts.alias[k]); i < arr.length; i++)(opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+            for(i = opts.boolean.length; i-- > 0;)for(j = (arr = opts.alias[opts.boolean[i]] || []).length; j-- > 0;)opts.boolean.push(arr[j]);
+            for(i = opts.string.length; i-- > 0;)for(j = (arr = opts.alias[opts.string[i]] || []).length; j-- > 0;)opts.string.push(arr[j]);
+            if (defaults) {
+                for(k in opts.default)if (name = typeof opts.default[k], arr = opts.alias[k] = opts.alias[k] || [], void 0 !== opts[name]) for(opts[name].push(k), i = 0; i < arr.length; i++)opts[name].push(arr[i]);
+            }
+            let keys = strict ? Object.keys(opts.alias) : [];
+            for(i = 0; i < len; i++){
+                if ("--" === (arg = args[i])) {
+                    out._ = out._.concat(args.slice(++i));
+                    break;
+                }
+                for(j = 0; j < arg.length && 45 === arg.charCodeAt(j); j++);
+                if (0 === j) out._.push(arg);
+                else if ("no-" === arg.substring(j, j + 3)) {
+                    if (name = arg.substring(j + 3), strict && !~keys.indexOf(name)) return opts.unknown(arg);
+                    out[name] = !1;
+                } else {
+                    for(idx = j + 1; idx < arg.length && 61 !== arg.charCodeAt(idx); idx++);
+                    for(name = arg.substring(j, idx), val = arg.substring(++idx) || i + 1 === len || 45 === ("" + args[i + 1]).charCodeAt(0) || args[++i], arr = 2 === j ? [
+                        name
+                    ] : name, idx = 0; idx < arr.length; idx++){
+                        if (name = arr[idx], strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+                        !function(out, key, val, opts) {
+                            var x, old = out[key], nxt = ~opts.string.indexOf(key) ? null == val || !0 === val ? "" : String(val) : "boolean" == typeof val ? val : ~opts.boolean.indexOf(key) ? "false" !== val && ("true" === val || (out._.push(0 * (x = +val) == 0 ? x : val), !!val)) : 0 * (x = +val) == 0 ? x : val;
+                            out[key] = null == old ? nxt : Array.isArray(old) ? old.concat(nxt) : [
+                                old,
+                                nxt
+                            ];
+                        }(out, name, idx + 1 < arr.length || val, opts);
+                    }
+                }
+            }
+            if (defaults) for(k in opts.default)void 0 === out[k] && (out[k] = opts.default[k]);
+            if (alibi) for(k in out)for(arr = opts.alias[k] || []; arr.length > 0;)out[arr.shift()] = out[k];
+            return out;
+        }(argv, mriOptions), args = (parsed = Object.keys(parsed).reduce((res, name)=>({
+                ...res,
+                [camelcaseOptionName(name)]: parsed[name]
+            }), {
+            _: []
+        }))._, options = {
+            "--": argsAfterDoubleDashes
+        }, ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue, transforms = Object.create(null);
+        for (let cliOption of cliOptions){
+            if (!ignoreDefault && void 0 !== cliOption.config.default) for (let name of cliOption.names)options[name] = cliOption.config.default;
+            Array.isArray(cliOption.config.type) && void 0 === transforms[cliOption.name] && (transforms[cliOption.name] = Object.create(null), transforms[cliOption.name].shouldTransform = !0, transforms[cliOption.name].transformFunction = cliOption.config.type[0]);
+        }
+        for (let key of Object.keys(parsed))if ("_" !== key) {
+            !function(obj, keys, val) {
+                let current = obj;
+                for(let i = 0; i < keys.length; i++){
+                    let key = keys[i];
+                    if (i === keys.length - 1) {
+                        current[key] = val;
+                        return;
+                    }
+                    if (null == current[key]) {
+                        let nextKeyIsArrayIndex = +keys[i + 1] > -1;
+                        current[key] = nextKeyIsArrayIndex ? [] : {};
+                    }
+                    current = current[key];
+                }
+            }(options, key.split("."), parsed[key]);
+            for (let key of Object.keys(transforms)){
+                let transform = transforms[key];
+                transform.shouldTransform && (options[key] = [
+                    options[key]
+                ].flat(), "function" == typeof transform.transformFunction && (options[key] = options[key].map(transform.transformFunction)));
+            }
+        }
+        return {
+            args,
+            options
+        };
+    }
+    runMatchedCommand() {
+        let { args, options, matchedCommand: command } = this;
+        if (!command || !command.commandAction) return;
+        command.checkUnknownOptions(), command.checkOptionValue(), command.checkRequiredArgs(), command.checkUnusedArgs();
+        let actionArgs = [];
+        return command.args.forEach((arg, index)=>{
+            arg.variadic ? actionArgs.push(args.slice(index)) : actionArgs.push(args[index]);
+        }), actionArgs.push(options), command.commandAction.apply(this, actionArgs);
+    }
+};
+let isCI = !!process.env.CI, isTTY = !!process.stdout?.isTTY, noColor = !!process.env.NO_COLOR, forceColor = !!process.env.FORCE_COLOR, disableColor = !1;
+disableColor = !!noColor || !forceColor && (isCI || !isTTY);
+let ANSI_SGR_RE = /\x1b\[[0-9;]*m/g, ANSI_OPEN_RE = /\x1b\[([0-9;]+)m/g, COLOR_HEX = {
+    brand: '#B39AFF',
+    red: '#F38BA8',
+    green: '#A6E3A1',
+    yellow: '#F9E2AF',
+    blue: '#89B4FA',
+    magenta: '#EE90DB',
+    cyan: '#89DCEB',
+    gray: '#6C7086'
+}, COLOR_HEX_TO_OPEN = Object.fromEntries(Object.values(COLOR_HEX).map((hex)=>[
+        hex,
+        ((hex)=>{
+            let r, g, b, value = (hex || '').trim().replace(/^#/, '');
+            if (/^[0-9a-fA-F]{3}$/.test(value)) r = Number.parseInt(value[0] + value[0], 16), g = Number.parseInt(value[1] + value[1], 16), b = Number.parseInt(value[2] + value[2], 16);
+            else {
+                if (!/^[0-9a-fA-F]{6}$/.test(value)) return '';
+                r = Number.parseInt(value.slice(0, 2), 16), g = Number.parseInt(value.slice(2, 4), 16), b = Number.parseInt(value.slice(4, 6), 16);
+            }
+            return `\x1b[38;2;${r};${g};${b}m`;
+        })(hex)
+    ])), hexColor = (hex)=>{
+    if (disableColor) return (input)=>String(input);
+    let open = COLOR_HEX_TO_OPEN[hex];
+    return open ? (input)=>`${open}${input}\x1b[39m` : (input)=>String(input);
+}, ansi = (open, close)=>(input)=>disableColor ? String(input) : `${open}${input}${close}`, colors = {
+    brand: hexColor(COLOR_HEX.brand),
+    red: hexColor(COLOR_HEX.red),
+    green: hexColor(COLOR_HEX.green),
+    yellow: hexColor(COLOR_HEX.yellow),
+    blue: hexColor(COLOR_HEX.blue),
+    magenta: hexColor(COLOR_HEX.magenta),
     cyan: hexColor(COLOR_HEX.cyan),
     gray: hexColor(COLOR_HEX.gray),
     bold: ansi('\x1b[1m', '\x1b[22m'),
@@ -1195,7 +2533,7 @@ function convertBasicAnsiColors(input) {
         return `${styleSeq}${open}`;
     }) : '';
 }
-var LogColor, logger_LogColor = ((LogColor = {}).error = "red", LogColor.warn = "yellow", LogColor.info = "cyan", LogColor.ready = "green", LogColor.event = "magenta", LogColor.wait = "blue", LogColor);
+var logger_LogColor = ((LogColor = {}).error = "red", LogColor.warn = "yellow", LogColor.info = "cyan", LogColor.ready = "green", LogColor.event = "magenta", LogColor.wait = "blue", LogColor);
 let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULES_EXPORTS_CONVENTION = 'camel-case', DEV_DEFAULT_FILENAME = {
     js: 'js/[name].js',
     jsAsync: 'js/async/[name].js',
@@ -1217,13 +2555,535 @@ let CSS_MODULES_LOCAL_IDENT_NAME = '[path][name]__[local]--[hash:5]', CSS_MODULE
   <body>
     <div id="${mountId}"></div>
   </body>
-</html>`, JS_REGEX = /\.[jt]s$/, JSX_REGEX = /\.[jt]sx$/, SCRIPT_REGEX = /\.[jt]sx?$/, CSS_REGEX = /\.css$/i, LESS_REGEX = /\.less$/i, SASS_REGEX = /\.s[ac]ss$/i, CSS_MODULES_RESOURCE_QUERY_REGEX = /[?&]module(?:[=&]|$)/;
+</html>`, JS_REGEX = /\.[jt]s$/, JSX_REGEX = /\.[jt]sx$/, SCRIPT_REGEX = /\.[jt]sx?$/, CSS_REGEX = /\.css$/i, LESS_REGEX = /\.less$/i, SASS_REGEX = /\.s[ac]ss$/i, CSS_MODULES_RESOURCE_QUERY_REGEX = /[?&]module(?:[=&]|$)/, external_path_ = __webpack_require__("path"), external_fs_ = __webpack_require__("fs");
+var __require = createRequire(import.meta.url);
+let SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+    return path.replace(SLASHES_REGEX, separator);
+}
+let WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function normalizePath(path, options) {
+    var path1;
+    let normalized, { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options, pathNeedsCleaning = "win32" === process.platform && path.includes("/") || path.startsWith(".");
+    return resolvePaths && (path = (0, external_path_.resolve)(path)), ((normalizePath$1 || pathNeedsCleaning) && (path1 = path, (normalized = (0, external_path_.normalize)(path1)).length > 1 && normalized[normalized.length - 1] === external_path_.sep && (normalized = normalized.substring(0, normalized.length - 1)), path = normalized), "." === path) ? "" : convertSlashes(path[path.length - 1] !== pathSeparator ? path + pathSeparator : path, pathSeparator);
+}
+function joinPathWithBasePath(filename, directoryPath) {
+    return directoryPath + filename;
+}
+function joinPath(filename) {
+    return filename;
+}
+let pushDirectory = (directoryPath, paths)=>{
+    paths.push(directoryPath || ".");
+}, pushDirectoryFilter = (directoryPath, paths, filters)=>{
+    let path = directoryPath || ".";
+    filters.every((filter)=>filter(path, !0)) && paths.push(path);
+}, empty$2 = ()=>{}, pushFileFilterAndCount = (filename, _paths, counts, filters)=>{
+    filters.every((filter)=>filter(filename, !1)) && counts.files++;
+}, pushFileFilter = (filename, paths, _counts, filters)=>{
+    filters.every((filter)=>filter(filename, !1)) && paths.push(filename);
+}, pushFileCount = (_filename, _paths, counts, _filters)=>{
+    counts.files++;
+}, pushFile = (filename, paths)=>{
+    paths.push(filename);
+}, empty$1 = ()=>{}, getArray = (paths)=>paths, getArrayGroup = ()=>[
+        ""
+    ].slice(0, 0), groupFiles = (groups, directory, files)=>{
+    groups.push({
+        directory,
+        files,
+        dir: directory
+    });
+}, empty = ()=>{}, resolveSymlinksAsync = function(path, state, callback$1) {
+    let { queue, fs, options: { suppressErrors } } = state;
+    queue.enqueue(), fs.realpath(path, (error, resolvedPath)=>{
+        if (error) return queue.dequeue(suppressErrors ? null : error, state);
+        fs.stat(resolvedPath, (error$1, stat)=>error$1 ? queue.dequeue(suppressErrors ? null : error$1, state) : stat.isDirectory() && isRecursive(path, resolvedPath, state) ? queue.dequeue(null, state) : void (callback$1(stat, resolvedPath), queue.dequeue(null, state)));
+    });
+}, resolveSymlinks = function(path, state, callback$1) {
+    let { queue, fs, options: { suppressErrors } } = state;
+    queue.enqueue();
+    try {
+        let resolvedPath = fs.realpathSync(path), stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+        callback$1(stat, resolvedPath);
+    } catch (e) {
+        if (!suppressErrors) throw e;
+    }
+};
+function isRecursive(path, resolved, state) {
+    if (state.options.useRealPaths) {
+        var resolved1, state1;
+        return resolved1 = resolved, (state1 = state).visited.includes(resolved1 + state1.options.pathSeparator);
+    }
+    let parent = (0, external_path_.dirname)(path), depth = 1;
+    for(; parent !== state.root && depth < 2;){
+        let resolvedPath = state.symlinks.get(parent);
+        resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)) ? depth++ : parent = (0, external_path_.dirname)(parent);
+    }
+    return state.symlinks.set(path, resolved), depth > 1;
+}
+let onlyCountsSync = (state)=>state.counts, groupsSync = (state)=>state.groups, defaultSync = (state)=>state.paths, limitFilesSync = (state)=>state.paths.slice(0, state.options.maxFiles), onlyCountsAsync = (state, error, callback$1)=>(report(error, callback$1, state.counts, state.options.suppressErrors), null), defaultAsync = (state, error, callback$1)=>(report(error, callback$1, state.paths, state.options.suppressErrors), null), limitFilesAsync = (state, error, callback$1)=>(report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors), null), groupsAsync = (state, error, callback$1)=>(report(error, callback$1, state.groups, state.options.suppressErrors), null);
+function report(error, callback$1, output, suppressErrors) {
+    callback$1(error && !suppressErrors ? error : null, output);
+}
+let readdirOpts = {
+    withFileTypes: !0
+}, walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
+    if (state.queue.enqueue(), currentDepth < 0) return state.queue.dequeue(null, state);
+    let { fs } = state;
+    state.visited.push(crawlPath), state.counts.directories++, fs.readdir(crawlPath || ".", readdirOpts, (error, entries = [])=>{
+        callback$1(entries, directoryPath, currentDepth), state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+    });
+}, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
+    let { fs } = state;
+    if (currentDepth < 0) return;
+    state.visited.push(crawlPath), state.counts.directories++;
+    let entries = [];
+    try {
+        entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+    } catch (e) {
+        if (!state.options.suppressErrors) throw e;
+    }
+    callback$1(entries, directoryPath, currentDepth);
+};
+var Queue = class {
+    count = 0;
+    constructor(onQueueEmpty){
+        this.onQueueEmpty = onQueueEmpty;
+    }
+    enqueue() {
+        return this.count++, this.count;
+    }
+    dequeue(error, output) {
+        this.onQueueEmpty && (--this.count <= 0 || error) && (this.onQueueEmpty(error, output), error && (output.controller.abort(), this.onQueueEmpty = void 0));
+    }
+}, Counter = class {
+    _files = 0;
+    _directories = 0;
+    set files(num) {
+        this._files = num;
+    }
+    get files() {
+        return this._files;
+    }
+    set directories(num) {
+        this._directories = num;
+    }
+    get directories() {
+        return this._directories;
+    }
+    get dirs() {
+        return this._directories;
+    }
+}, Aborter = class {
+    aborted = !1;
+    abort() {
+        this.aborted = !0;
+    }
+}, Walker = class {
+    root;
+    isSynchronous;
+    state;
+    joinPath;
+    pushDirectory;
+    pushFile;
+    getArray;
+    groupFiles;
+    resolveSymlink;
+    walkDirectory;
+    callbackInvoker;
+    constructor(root, options, callback$1){
+        var path, isSynchronous;
+        this.isSynchronous = !callback$1, this.callbackInvoker = function(options, isSynchronous) {
+            let { onlyCounts, group, maxFiles } = options;
+            return onlyCounts ? isSynchronous ? onlyCountsSync : onlyCountsAsync : group ? isSynchronous ? groupsSync : groupsAsync : maxFiles ? isSynchronous ? limitFilesSync : limitFilesAsync : isSynchronous ? defaultSync : defaultAsync;
+        }(options, this.isSynchronous), this.root = normalizePath(root, options), this.state = {
+            root: "/" === (path = this.root) || WINDOWS_ROOT_DIR_REGEX.test(path) ? this.root : this.root.slice(0, -1),
+            paths: [
+                ""
+            ].slice(0, 0),
+            groups: [],
+            counts: new Counter(),
+            options,
+            queue: new Queue((error, state)=>this.callbackInvoker(state, error, callback$1)),
+            symlinks: new Map(),
+            visited: [
+                ""
+            ].slice(0, 0),
+            controller: new Aborter(),
+            fs: options.fs || external_fs_
+        }, this.joinPath = function(root, options) {
+            let { relativePaths, includeBasePath } = options;
+            return relativePaths && root ? function(filename, directoryPath) {
+                return directoryPath.startsWith(root) ? directoryPath.slice(root.length) + filename : convertSlashes((0, external_path_.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+            } : includeBasePath ? joinPathWithBasePath : joinPath;
+        }(this.root, options), this.pushDirectory = function(root, options) {
+            let { includeDirs, filters, relativePaths } = options;
+            if (!includeDirs) return empty$2;
+            if (relativePaths) return filters && filters.length ? function(directoryPath, paths, filters) {
+                let relativePath = directoryPath.substring(root.length) || ".";
+                filters.every((filter)=>filter(relativePath, !0)) && paths.push(relativePath);
+            } : function(directoryPath, paths) {
+                paths.push(directoryPath.substring(root.length) || ".");
+            };
+            return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+        }(this.root, options), this.pushFile = function(options) {
+            let { excludeFiles, filters, onlyCounts } = options;
+            return excludeFiles ? empty$1 : filters && filters.length ? onlyCounts ? pushFileFilterAndCount : pushFileFilter : onlyCounts ? pushFileCount : pushFile;
+        }(options), this.getArray = options.group ? getArrayGroup : getArray, this.groupFiles = options.group ? groupFiles : empty, this.resolveSymlink = (isSynchronous = this.isSynchronous, !options.resolveSymlinks || options.excludeSymlinks ? null : isSynchronous ? resolveSymlinks : resolveSymlinksAsync), this.walkDirectory = this.isSynchronous ? walkSync : walkAsync;
+    }
+    start() {
+        return this.pushDirectory(this.root, this.state.paths, this.state.options.filters), this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk), this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+    }
+    walk = (entries, directoryPath, depth)=>{
+        let { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+        if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+        let files = this.getArray(this.state.paths);
+        for(let i = 0; i < entries.length; ++i){
+            let entry = entries[i];
+            if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+                let filename = this.joinPath(entry.name, directoryPath);
+                this.pushFile(filename, files, this.state.counts, filters);
+            } else if (entry.isDirectory()) {
+                let path = directoryPath + entry.name + this.state.options.pathSeparator;
+                if (exclude && exclude(entry.name, path)) continue;
+                this.pushDirectory(path, paths, filters), this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+            } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+                let path = directoryPath + entry.name;
+                this.resolveSymlink(path, this.state, (stat, resolvedPath)=>{
+                    if (stat.isDirectory()) resolvedPath = normalizePath(resolvedPath, this.state.options), exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator) || this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                    else {
+                        resolvedPath = useRealPaths ? resolvedPath : path;
+                        let filename = (0, external_path_.basename)(resolvedPath), directoryPath$1 = normalizePath((0, external_path_.dirname)(resolvedPath), this.state.options);
+                        resolvedPath = this.joinPath(filename, directoryPath$1), this.pushFile(resolvedPath, files, this.state.counts, filters);
+                    }
+                });
+            }
+        }
+        this.groupFiles(this.state.groups, directoryPath, files);
+    };
+};
+function dist_callback(root, options, callback$1) {
+    new Walker(root, options, callback$1).start();
+}
+var APIBuilder = class {
+    constructor(root, options){
+        this.root = root, this.options = options;
+    }
+    withPromise() {
+        var root, options;
+        return root = this.root, options = this.options, new Promise((resolve$1, reject)=>{
+            dist_callback(root, options, (err, output)=>{
+                if (err) return reject(err);
+                resolve$1(output);
+            });
+        });
+    }
+    withCallback(cb) {
+        dist_callback(this.root, this.options, cb);
+    }
+    sync() {
+        return new Walker(this.root, this.options).start();
+    }
+};
+let pm = null;
+try {
+    __require.resolve("picomatch"), pm = __require("picomatch");
+} catch  {}
+var Builder = class {
+    globCache = {};
+    options = {
+        maxDepth: 1 / 0,
+        suppressErrors: !0,
+        pathSeparator: external_path_.sep,
+        filters: []
+    };
+    globFunction;
+    constructor(options){
+        this.options = {
+            ...this.options,
+            ...options
+        }, this.globFunction = this.options.globFunction;
+    }
+    group() {
+        return this.options.group = !0, this;
+    }
+    withPathSeparator(separator) {
+        return this.options.pathSeparator = separator, this;
+    }
+    withBasePath() {
+        return this.options.includeBasePath = !0, this;
+    }
+    withRelativePaths() {
+        return this.options.relativePaths = !0, this;
+    }
+    withDirs() {
+        return this.options.includeDirs = !0, this;
+    }
+    withMaxDepth(depth) {
+        return this.options.maxDepth = depth, this;
+    }
+    withMaxFiles(limit) {
+        return this.options.maxFiles = limit, this;
+    }
+    withFullPaths() {
+        return this.options.resolvePaths = !0, this.options.includeBasePath = !0, this;
+    }
+    withErrors() {
+        return this.options.suppressErrors = !1, this;
+    }
+    withSymlinks({ resolvePaths = !0 } = {}) {
+        return this.options.resolveSymlinks = !0, this.options.useRealPaths = resolvePaths, this.withFullPaths();
+    }
+    withAbortSignal(signal) {
+        return this.options.signal = signal, this;
+    }
+    normalize() {
+        return this.options.normalizePath = !0, this;
+    }
+    filter(predicate) {
+        return this.options.filters.push(predicate), this;
+    }
+    onlyDirs() {
+        return this.options.excludeFiles = !0, this.options.includeDirs = !0, this;
+    }
+    exclude(predicate) {
+        return this.options.exclude = predicate, this;
+    }
+    onlyCounts() {
+        return this.options.onlyCounts = !0, this;
+    }
+    crawl(root) {
+        return new APIBuilder(root || ".", this.options);
+    }
+    withGlobFunction(fn) {
+        return this.globFunction = fn, this;
+    }
+    crawlWithOptions(root, options) {
+        return this.options = {
+            ...this.options,
+            ...options
+        }, new APIBuilder(root || ".", this.options);
+    }
+    glob(...patterns) {
+        return this.globFunction ? this.globWithOptions(patterns) : this.globWithOptions(patterns, {
+            dot: !0
+        });
+    }
+    globWithOptions(patterns, ...options) {
+        let globFn = this.globFunction || pm;
+        if (!globFn) throw Error("Please specify a glob function to use glob matching.");
+        var isMatch = this.globCache[patterns.join("\0")];
+        return isMatch || (isMatch = globFn(patterns, ...options), this.globCache[patterns.join("\0")] = isMatch), this.options.filters.push((path)=>isMatch(path)), this;
+    }
+};
+let external_url_ = __webpack_require__("url"), picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js"), isReadonlyArray = Array.isArray, isWin = "win32" === process.platform, ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/, WIN32_ROOT_DIR = /^[A-Z]:\/$/i, isRoot = isWin ? (p)=>WIN32_ROOT_DIR.test(p) : (p)=>"/" === p;
+function buildFormat(cwd, root, absolute) {
+    if (cwd === root || root.startsWith(`${cwd}/`)) {
+        if (absolute) {
+            let start = isRoot(cwd) ? cwd.length : cwd.length + 1;
+            return (p, isDir)=>p.slice(start, isDir ? -1 : void 0) || ".";
+        }
+        let prefix = root.slice(cwd.length + 1);
+        return prefix ? (p, isDir)=>{
+            if ("." === p) return prefix;
+            let result = `${prefix}/${p}`;
+            return isDir ? result.slice(0, -1) : result;
+        } : (p, isDir)=>isDir && "." !== p ? p.slice(0, -1) : p;
+    }
+    return absolute ? (p)=>external_path_.posix.relative(cwd, p) || "." : (p)=>external_path_.posix.relative(cwd, `${root}/${p}`) || ".";
+}
+let splitPatternOptions = {
+    parts: !0
+};
+function splitPattern(path$1) {
+    var _result$parts;
+    let result = picomatch.scan(path$1, splitPatternOptions);
+    return (null == (_result$parts = result.parts) ? void 0 : _result$parts.length) ? result.parts : [
+        path$1
+    ];
+}
+let POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g, WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g, escapePath = isWin ? (path$1)=>path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&") : (path$1)=>path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+function dist_log(...tasks) {
+    console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+let PARENT_DIRECTORY = /^(\/?\.\.)+/, ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g, BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+    let result = pattern;
+    pattern.endsWith("/") && (result = pattern.slice(0, -1)), !result.endsWith("*") && expandDirectories && (result += "/**");
+    let escapedCwd = escapePath(cwd);
+    result = external_path_.default.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? external_path_.posix.relative(escapedCwd, result) : external_path_.posix.normalize(result);
+    let parentDirectoryMatch = PARENT_DIRECTORY.exec(result), parts = splitPattern(result);
+    if (null == parentDirectoryMatch ? void 0 : parentDirectoryMatch[0]) {
+        let n = (parentDirectoryMatch[0].length + 1) / 3, i = 0, cwdParts = escapedCwd.split("/");
+        for(; i < n && parts[i + n] === cwdParts[cwdParts.length + i - n];)result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".", i++;
+        let potentialRoot = external_path_.posix.join(cwd, parentDirectoryMatch[0].slice(3 * i));
+        !potentialRoot.startsWith(".") && props.root.length > potentialRoot.length && (props.root = potentialRoot, props.depthOffset = -n + i);
+    }
+    if (!isIgnore && props.depthOffset >= 0) {
+        null != props.commonPath || (props.commonPath = parts);
+        let newCommonPath = [], length = Math.min(props.commonPath.length, parts.length);
+        for(let i = 0; i < length; i++){
+            let part = parts[i];
+            if ("**" === part && !parts[i + 1]) {
+                newCommonPath.pop();
+                break;
+            }
+            if (part !== props.commonPath[i] || function(pattern, options) {
+                let scan = picomatch.scan(pattern);
+                return scan.isGlob || scan.negated;
+            }(part) || i === parts.length - 1) break;
+            newCommonPath.push(part);
+        }
+        props.depthOffset = newCommonPath.length, props.commonPath = newCommonPath, props.root = newCommonPath.length > 0 ? external_path_.posix.join(cwd, ...newCommonPath) : cwd;
+    }
+    return result;
+}
+function formatPaths(paths, relative) {
+    for(let i = paths.length - 1; i >= 0; i--){
+        let path$1 = paths[i];
+        paths[i] = relative(path$1);
+    }
+    return paths;
+}
+function getCrawler(patterns, inputOptions = {}) {
+    var cwd;
+    let options = process.env.TINYGLOBBY_DEBUG ? {
+        ...inputOptions,
+        debug: !0
+    } : inputOptions, cwd1 = (cwd = options.cwd) ? cwd instanceof URL ? (0, external_url_.fileURLToPath)(cwd).replace(BACKSLASHES, "/") : external_path_.default.resolve(cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+    if (options.debug && dist_log("globbing with:", {
+        patterns,
+        options,
+        cwd: cwd1
+    }), Array.isArray(patterns) && 0 === patterns.length) return [
+        {
+            sync: ()=>[],
+            withPromise: async ()=>[]
+        },
+        !1
+    ];
+    let props = {
+        root: cwd1,
+        commonPath: null,
+        depthOffset: 0
+    }, processed = function({ patterns = [
+        "**/*"
+    ], ignore = [], expandDirectories = !0 }, cwd, props) {
+        "string" == typeof patterns && (patterns = [
+            patterns
+        ]), "string" == typeof ignore && (ignore = [
+            ignore
+        ]);
+        let matchPatterns = [], ignorePatterns = [];
+        for (let pattern of ignore)pattern && ("!" !== pattern[0] || "(" === pattern[1]) && ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, !0));
+        for (let pattern of patterns)pattern && ("!" !== pattern[0] || "(" === pattern[1] ? matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, !1)) : ("!" !== pattern[1] || "(" === pattern[2]) && ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, !0)));
+        return {
+            match: matchPatterns,
+            ignore: ignorePatterns
+        };
+    }({
+        ...options,
+        patterns
+    }, cwd1, props);
+    options.debug && dist_log("internal processing patterns:", processed);
+    let matchOptions = {
+        dot: options.dot,
+        nobrace: !1 === options.braceExpansion,
+        nocase: !1 === options.caseSensitiveMatch,
+        noextglob: !1 === options.extglob,
+        noglobstar: !1 === options.globstar,
+        posix: !0
+    }, matcher = picomatch(processed.match, {
+        ...matchOptions,
+        ignore: processed.ignore
+    }), ignore = picomatch(processed.ignore, matchOptions), partialMatcher = function(patterns, options = {}) {
+        let patternsCount = patterns.length, patternsParts = Array(patternsCount), matchers = Array(patternsCount), globstarEnabled = !options.noglobstar;
+        for(let i = 0; i < patternsCount; i++){
+            let parts = splitPattern(patterns[i]);
+            patternsParts[i] = parts;
+            let partsCount = parts.length, partMatchers = Array(partsCount);
+            for(let j = 0; j < partsCount; j++)partMatchers[j] = picomatch(parts[j], options);
+            matchers[i] = partMatchers;
+        }
+        return (input)=>{
+            let inputParts = input.split("/");
+            if (".." === inputParts[0] && ONLY_PARENT_DIRECTORIES.test(input)) return !0;
+            for(let i = 0; i < patterns.length; i++){
+                let patternParts = patternsParts[i], matcher = matchers[i], inputPatternCount = inputParts.length, minParts = Math.min(inputPatternCount, patternParts.length), j = 0;
+                for(; j < minParts;){
+                    let part = patternParts[j];
+                    if (part.includes("/")) return !0;
+                    if (!matcher[j](inputParts[j])) break;
+                    if (globstarEnabled && "**" === part) return !0;
+                    j++;
+                }
+                if (j === inputPatternCount) return !0;
+            }
+            return !1;
+        };
+    }(processed.match, matchOptions), format = buildFormat(cwd1, props.root, options.absolute), formatExclude = options.absolute ? format : buildFormat(cwd1, props.root, !0), fdirOptions = {
+        filters: [
+            options.debug ? (p, isDirectory)=>{
+                let path$1 = format(p, isDirectory), matches = matcher(path$1);
+                return matches && dist_log(`matched ${path$1}`), matches;
+            } : (p, isDirectory)=>matcher(format(p, isDirectory))
+        ],
+        exclude: options.debug ? (_, p)=>{
+            let relativePath = formatExclude(p, !0), skipped = "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+            return skipped ? dist_log(`skipped ${p}`) : dist_log(`crawling ${p}`), skipped;
+        } : (_, p)=>{
+            let relativePath = formatExclude(p, !0);
+            return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
+        },
+        fs: options.fs ? {
+            readdir: options.fs.readdir || external_fs_.default.readdir,
+            readdirSync: options.fs.readdirSync || external_fs_.default.readdirSync,
+            realpath: options.fs.realpath || external_fs_.default.realpath,
+            realpathSync: options.fs.realpathSync || external_fs_.default.realpathSync,
+            stat: options.fs.stat || external_fs_.default.stat,
+            statSync: options.fs.statSync || external_fs_.default.statSync
+        } : void 0,
+        pathSeparator: "/",
+        relativePaths: !0,
+        resolveSymlinks: !0,
+        signal: options.signal
+    };
+    void 0 !== options.deep && (fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset)), options.absolute && (fdirOptions.relativePaths = !1, fdirOptions.resolvePaths = !0, fdirOptions.includeBasePath = !0), !1 === options.followSymbolicLinks && (fdirOptions.resolveSymlinks = !1, fdirOptions.excludeSymlinks = !0), options.onlyDirectories ? (fdirOptions.excludeFiles = !0, fdirOptions.includeDirs = !0) : !1 === options.onlyFiles && (fdirOptions.includeDirs = !0), props.root = props.root.replace(BACKSLASHES, "");
+    let root = props.root;
+    options.debug && dist_log("internal properties:", props);
+    let relative = cwd1 !== root && !options.absolute && function(cwd, root) {
+        if (root.startsWith(`${cwd}/`)) {
+            let prefix = root.slice(cwd.length + 1);
+            return (p)=>`${prefix}/${p}`;
+        }
+        return (p)=>{
+            let result = external_path_.posix.relative(cwd, `${root}/${p}`);
+            return p.endsWith("/") && "" !== result ? `${result}/` : result || ".";
+        };
+    }(cwd1, props.root);
+    return [
+        new Builder(fdirOptions).crawl(root),
+        relative
+    ];
+}
+async function dist_glob(patternsOrOptions, options) {
+    if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw Error("Cannot pass patterns as both an argument and an option");
+    let isModern = isReadonlyArray(patternsOrOptions) || "string" == typeof patternsOrOptions, opts = isModern ? options : patternsOrOptions, [crawler, relative] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
+    return relative ? formatPaths(await crawler.withPromise(), relative) : crawler.withPromise();
+}
+function globSync(patternsOrOptions, options) {
+    if (patternsOrOptions && (null == options ? void 0 : options.patterns)) throw Error("Cannot pass patterns as both an argument and an option");
+    let isModern = isReadonlyArray(patternsOrOptions) || "string" == typeof patternsOrOptions, opts = isModern ? options : patternsOrOptions, [crawler, relative] = getCrawler(isModern ? patternsOrOptions : patternsOrOptions.patterns, opts);
+    return relative ? formatPaths(crawler.sync(), relative) : crawler.sync();
+}
 var utils_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 let 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, utils_isProd = ()=>'production' === getNodeEnv(), isWin = ()=>'win32' === process.platform, isString = (str)=>'string' == typeof str, isBoolean = (bool)=>'boolean' == typeof bool, isUndefined = (obj)=>void 0 === obj, isFunction = (func)=>'function' == typeof func, isObject = (obj)=>null !== obj && 'object' == typeof obj, isPlainObject = (obj)=>isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj), isRegExp = (obj)=>'[object RegExp]' === Object.prototype.toString.call(obj), prettyTime = (seconds)=>{
+}, isDev = ()=>'development' === getNodeEnv(), utils_isDevServer = ()=>'true' === process.env.DEV_SERVER, utils_isProd = ()=>'production' === getNodeEnv(), utils_isWin = ()=>'win32' === process.platform, utils_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;
@@ -1237,20 +3097,14 @@ let getNodeEnv = ()=>process.env.NODE_ENV, setNodeEnv = (env)=>{
     }
     let lastKey = pathArray.at(-1);
     return void 0 === current[lastKey] && (current[lastKey] = defaultValue), current[lastKey];
-}, set = (target, pathArray, value)=>{
+}, utils_set = (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);
-        });
-    }), normalizePublicPath = (base)=>{
+}, normalizePublicPath = (base)=>{
     if (!base) return '/';
     let normalized = base;
     return normalized.startsWith('/') || (normalized = `/${normalized}`), normalized.endsWith('/') || (normalized = `${normalized}/`), normalized;
@@ -1550,7 +3404,7 @@ async function loadConfig({ cliOptions, command }) {
         if (void 0 === (configExport = await configExport(params))) throw Error('unpack config function must return a config object.');
     }
     let applyOption = (path, value)=>{
-        void 0 !== value && set(configExport, path, value);
+        void 0 !== value && utils_set(configExport, path, value);
     };
     return applyOption([
         'server',
@@ -1638,7 +3492,225 @@ let findExists = (files)=>{
     '.less',
     '.scss',
     '.sass'
-], BROWSER_LOGS_ENDPOINT = '/__browser_logs__', SOURCE_REGEX = /\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|vue|svelte)$/, gzip = promisify(node_zlib.gzip), numberFormatter = new Intl.NumberFormat('en', {
+];
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
+for(let i = 0; i < chars.length; i++){
+    let c = chars.charCodeAt(i);
+    intToChar[i] = c, charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+    let value = 0, shift = 0, integer = 0;
+    do value |= (31 & (integer = charToInt[reader.next()])) << shift, shift += 5;
+    while (32 & integer);
+    let shouldNegate = 1 & value;
+    return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
+}
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+    do {
+        let clamped = 31 & delta;
+        (delta >>>= 5) > 0 && (clamped |= 32), builder.write(intToChar[clamped]);
+    }while (delta > 0);
+    return num;
+}
+function hasMoreVlq(reader, max) {
+    return !(reader.pos >= max) && 44 !== reader.peek();
+}
+var td = "u" > typeof TextDecoder ? new TextDecoder() : "u" > typeof Buffer ? {
+    decode: (buf)=>Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString()
+} : {
+    decode (buf) {
+        let out = "";
+        for(let i = 0; i < buf.length; i++)out += String.fromCharCode(buf[i]);
+        return out;
+    }
+}, StringWriter = class {
+    constructor(){
+        this.pos = 0, this.out = "", this.buffer = new Uint8Array(16384);
+    }
+    write(v) {
+        let { buffer } = this;
+        buffer[this.pos++] = v, 16384 === this.pos && (this.out += td.decode(buffer), this.pos = 0);
+    }
+    flush() {
+        let { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}, StringReader = class {
+    constructor(buffer){
+        this.pos = 0, this.buffer = buffer;
+    }
+    next() {
+        return this.buffer.charCodeAt(this.pos++);
+    }
+    peek() {
+        return this.buffer.charCodeAt(this.pos);
+    }
+    indexOf(char) {
+        let { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+        return -1 === idx ? buffer.length : idx;
+    }
+};
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
+let schemeRegex = /^[\w+.-]+:\/\//, urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/, fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsolutePath(input) {
+    return input.startsWith('/');
+}
+function isRelative(input) {
+    return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+    let match = urlRegex.exec(input);
+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+    return {
+        scheme,
+        user,
+        host,
+        port,
+        path,
+        query,
+        hash,
+        type: 7
+    };
+}
+function parseUrl(input) {
+    if (input.startsWith('//')) {
+        let url = parseAbsoluteUrl('http:' + input);
+        return url.scheme = '', url.type = 6, url;
+    }
+    if (isAbsolutePath(input)) {
+        let url = parseAbsoluteUrl('http://foo.com' + input);
+        return url.scheme = '', url.host = '', url.type = 5, url;
+    }
+    if (input.startsWith('file:')) {
+        let match, path;
+        return path = (match = fileRegex.exec(input))[2], makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+    }
+    if (schemeRegex.test(input)) return parseAbsoluteUrl(input);
+    let url = parseAbsoluteUrl('http://foo.com/' + input);
+    return url.scheme = '', url.host = '', url.type = input ? input.startsWith('?') ? 3 : input.startsWith('#') ? 2 : 4 : 1, url;
+}
+function resolve_uri_normalizePath(url, type) {
+    let rel = type <= 4, pieces = url.path.split('/'), pointer = 1, positive = 0, addTrailingSlash = !1;
+    for(let i = 1; i < pieces.length; i++){
+        let piece = pieces[i];
+        if (!piece) {
+            addTrailingSlash = !0;
+            continue;
+        }
+        if (addTrailingSlash = !1, '.' !== piece) {
+            if ('..' === piece) {
+                positive ? (addTrailingSlash = !0, positive--, pointer--) : rel && (pieces[pointer++] = piece);
+                continue;
+            }
+            pieces[pointer++] = piece, positive++;
+        }
+    }
+    let path = '';
+    for(let i = 1; i < pointer; i++)path += '/' + pieces[i];
+    path && (!addTrailingSlash || path.endsWith('/..')) || (path += '/'), url.path = path;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+    for(let i = start; i < mappings.length; i++)if (!function(line) {
+        for(let j = 1; j < line.length; j++)if (line[j][0] < line[j - 1][0]) return !1;
+        return !0;
+    }(mappings[i])) return i;
+    return mappings.length;
+}
+function trace_mapping_sortComparator(a, b) {
+    return a[0] - b[0];
+}
+var found = !1, TraceMap = class {
+    constructor(map, mapUrl){
+        var map1;
+        let from, prefix, isString = "string" == typeof map;
+        if (!isString && map._decodedMemo) return map;
+        let parsed = "string" == typeof (map1 = map) ? JSON.parse(map1) : map1, { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+        this.version = version, this.file = file, this.names = names || [], this.sourceRoot = sourceRoot, this.sources = sources, this.sourcesContent = sourcesContent, this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+        let resolve = (from = function(path) {
+            if (!path) return "";
+            let index = path.lastIndexOf("/");
+            return path.slice(0, index + 1);
+        }(mapUrl), prefix = sourceRoot ? sourceRoot + "/" : "", (source)=>(function(input, base) {
+                if (!input && !base) return '';
+                let url = parseUrl(input), inputType = url.type;
+                if (base && 7 !== inputType) {
+                    let baseUrl = parseUrl(base), baseType = baseUrl.type;
+                    switch(inputType){
+                        case 1:
+                            url.hash = baseUrl.hash;
+                        case 2:
+                            url.query = baseUrl.query;
+                        case 3:
+                        case 4:
+                            resolve_uri_normalizePath(baseUrl, baseUrl.type), '/' === url.path ? url.path = baseUrl.path : url.path = function(path) {
+                                if (path.endsWith('/..')) return path;
+                                let index = path.lastIndexOf('/');
+                                return path.slice(0, index + 1);
+                            }(baseUrl.path) + url.path;
+                        case 5:
+                            url.user = baseUrl.user, url.host = baseUrl.host, url.port = baseUrl.port;
+                        case 6:
+                            url.scheme = baseUrl.scheme;
+                    }
+                    baseType > inputType && (inputType = baseType);
+                }
+                resolve_uri_normalizePath(url, inputType);
+                let queryHash = url.query + url.hash;
+                switch(inputType){
+                    case 2:
+                    case 3:
+                        return queryHash;
+                    case 4:
+                        {
+                            let path = url.path.slice(1);
+                            if (!path) return queryHash || '.';
+                            if (isRelative(base || input) && !isRelative(path)) return './' + path + queryHash;
+                            return path + queryHash;
+                        }
+                    case 5:
+                        return url.path + queryHash;
+                    default:
+                        return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+                }
+            })(prefix + (source || ""), from));
+        this.resolvedSources = sources.map(resolve);
+        let { mappings } = parsed;
+        if ("string" == typeof mappings) this._encoded = mappings, this._decoded = void 0;
+        else if (Array.isArray(mappings)) this._encoded = void 0, this._decoded = function(mappings, owned) {
+            let unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+            if (unsortedIndex === mappings.length) return mappings;
+            owned || (mappings = mappings.slice());
+            for(let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)){
+                var line;
+                mappings[i] = (line = mappings[i], owned || (line = line.slice()), line.sort(trace_mapping_sortComparator));
+            }
+            return mappings;
+        }(mappings, isString);
+        else if (parsed.sections) throw Error("TraceMap passed sectioned source map, please use FlattenMap export instead");
+        else throw Error(`invalid source map: ${JSON.stringify(parsed)}`);
+        this._decodedMemo = {
+            lastKey: -1,
+            lastNeedle: -1,
+            lastIndex: -1
+        }, this._bySources = void 0, this._bySourceMemos = void 0;
+    }
+};
+function OMapping(source, line, column, name) {
+    return {
+        source,
+        line,
+        column,
+        name
+    };
+}
+var UNKNOWN_FUNCTION = '<unknown>', chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i, chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/, winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i, geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i, geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i, javaScriptCoreRe = /^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i, nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+let BROWSER_LOGS_ENDPOINT = '/__browser_logs__', SOURCE_REGEX = /\.(js|jsx|mjs|cjs|ts|tsx|mts|cts|vue|svelte)$/, gzip = promisify(node_zlib.gzip), numberFormatter = new Intl.NumberFormat('en', {
     maximumFractionDigits: 2,
     minimumFractionDigits: 2
 }), displaySize = (bytes)=>`${numberFormatter.format(bytes / 1000)} kB`;
@@ -1710,56 +3782,674 @@ let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|
         let publicBase = `/${rel}`.replace(/\/{2,}/g, '/').replace(/\/$/, ''), rest = trimmed.slice(key.length);
         return `${publicBase}${rest}`.replace(/\/{2,}/g, '/');
     }
-    let normalized = trimmed.replace(/\\/g, '/'), firstChar = normalized[0];
-    if ('@' === firstChar || '~' === firstChar || '#' === firstChar) {
-        let slashIndex = normalized.indexOf('/'), aliasKey = normalized.slice(0, slashIndex);
-        aliasEntries.map(([rawKey])=>rawKey.endsWith('/') ? rawKey.slice(0, -1) : rawKey).filter(Boolean).includes(aliasKey) || warnedMissingAliasKeys.has(aliasKey) || (warnedMissingAliasKeys.add(aliasKey), logger_logger.warn(`Unrecognized alias "${aliasKey}" in glob pattern: "${trimmed}", please ensure it is defined in "resolve.alias".`));
+    let normalized = trimmed.replace(/\\/g, '/'), firstChar = normalized[0];
+    if ('@' === firstChar || '~' === firstChar || '#' === firstChar) {
+        let slashIndex = normalized.indexOf('/'), aliasKey = normalized.slice(0, slashIndex);
+        aliasEntries.map(([rawKey])=>rawKey.endsWith('/') ? rawKey.slice(0, -1) : rawKey).filter(Boolean).includes(aliasKey) || warnedMissingAliasKeys.has(aliasKey) || (warnedMissingAliasKeys.add(aliasKey), logger_logger.warn(`Unrecognized alias "${aliasKey}" in glob pattern: "${trimmed}", please ensure it is defined in "resolve.alias".`));
+    }
+    return trimmed;
+}, SPECIAL_NO_ENTRY_DEPS = [
+    '@iconify-icons/material-symbols'
+], FRAMEWORKS = [
+    'react',
+    'react-dom',
+    'react-router-dom',
+    'vue',
+    'vue-router'
+], getExternalLibraryName = (pkgName)=>{
+    let externalAlias = {
+        'react-dom': 'ReactDOM',
+        'react-router-dom': 'ReactRouterDOM'
+    };
+    return externalAlias[pkgName] ? externalAlias[pkgName] : pkgName.replace(/^@/, '').split(/[/\-.]/).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+}, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, normalizeSvg = (content)=>content.replace(/<\?xml[\s\S]*?\?>/gi, '').replace(/<!DOCTYPE[\s\S]*?>/gi, '').replace(/<!--[\s\S]*?-->/g, '').trim(), extractSvgContent = (content)=>{
+    let match = content.match(/<svg\b([^>]*)>/i), viewBoxMatch = match?.[1]?.match(/viewBox\s*=\s*["']([^"']+)["']/i);
+    return {
+        inner: content.replace(/^[\s\S]*?<svg\b[^>]*>/i, '').replace(/<\/svg>[\s\S]*$/i, '').trim(),
+        viewBox: viewBoxMatch?.[1]
+    };
+}, readSvgFiles = (dir, collected = [])=>{
+    if (!node_fs.existsSync(dir)) return collected;
+    for (let entry of node_fs.readdirSync(dir, {
+        withFileTypes: !0
+    })){
+        let fullPath = node_path.join(dir, entry.name);
+        entry.isDirectory() ? readSvgFiles(fullPath, collected) : entry.isFile() && entry.name.toLowerCase().endsWith('.svg') && collected.push(fullPath);
+    }
+    return collected;
+}, toSymbolId = (filePath, iconDir, symbolId)=>{
+    let relative = node_path.relative(iconDir, filePath), parsed = node_path.parse(relative), dir = parsed.dir.split(node_path.sep).filter(Boolean).join('-'), name = parsed.name;
+    if ('function' == typeof symbolId) return symbolId(name, filePath);
+    let id = (symbolId || 'icon-[dir]-[name]').replace(/\[name\]/g, name).replace(/\[dir\]/g, dir);
+    return id.replace(/--+/g, '-').replace(/^-+|-+$/g, '');
+}, BROWSERSLIST_CONFIG_FILES = [
+    '.browserslistrc',
+    '.browserslistrc.json',
+    '.browserslistrc.yaml',
+    '.browserslistrc.yml',
+    'browserslist',
+    'browserslist.config.js',
+    'browserslist.config.cjs',
+    'browserslist.config.mjs'
+];
+class BitSet {
+    constructor(arg){
+        this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+    }
+    add(n) {
+        this.bits[n >> 5] |= 1 << (31 & n);
+    }
+    has(n) {
+        return !!(this.bits[n >> 5] & 1 << (31 & n));
+    }
+}
+class Chunk {
+    constructor(start, end, content){
+        this.start = start, this.end = end, this.original = content, this.intro = '', this.outro = '', this.content = content, this.storeName = !1, this.edited = !1, this.previous = null, this.next = null;
+    }
+    appendLeft(content) {
+        this.outro += content;
+    }
+    appendRight(content) {
+        this.intro = this.intro + content;
+    }
+    clone() {
+        let chunk = new Chunk(this.start, this.end, this.original);
+        return chunk.intro = this.intro, chunk.outro = this.outro, chunk.content = this.content, chunk.storeName = this.storeName, chunk.edited = this.edited, chunk;
+    }
+    contains(index) {
+        return this.start < index && index < this.end;
+    }
+    eachNext(fn) {
+        let chunk = this;
+        for(; chunk;)fn(chunk), chunk = chunk.next;
+    }
+    eachPrevious(fn) {
+        let chunk = this;
+        for(; chunk;)fn(chunk), chunk = chunk.previous;
+    }
+    edit(content, storeName, contentOnly) {
+        return this.content = content, contentOnly || (this.intro = '', this.outro = ''), this.storeName = storeName, this.edited = !0, this;
+    }
+    prependLeft(content) {
+        this.outro = content + this.outro;
+    }
+    prependRight(content) {
+        this.intro = content + this.intro;
+    }
+    reset() {
+        this.intro = '', this.outro = '', this.edited && (this.content = this.original, this.storeName = !1, this.edited = !1);
+    }
+    split(index) {
+        let sliceIndex = index - this.start, originalBefore = this.original.slice(0, sliceIndex), originalAfter = this.original.slice(sliceIndex);
+        this.original = originalBefore;
+        let newChunk = new Chunk(index, this.end, originalAfter);
+        return newChunk.outro = this.outro, this.outro = '', this.end = index, this.edited ? (newChunk.edit('', !1), this.content = '') : this.content = originalBefore, newChunk.next = this.next, newChunk.next && (newChunk.next.previous = newChunk), newChunk.previous = this, this.next = newChunk, newChunk;
+    }
+    toString() {
+        return this.intro + this.content + this.outro;
+    }
+    trimEnd(rx) {
+        if (this.outro = this.outro.replace(rx, ''), this.outro.length) return !0;
+        let trimmed = this.content.replace(rx, '');
+        return trimmed.length ? (trimmed !== this.content && (this.split(this.start + trimmed.length).edit('', void 0, !0), this.edited && this.edit(trimmed, this.storeName, !0)), !0) : (this.edit('', void 0, !0), this.intro = this.intro.replace(rx, ''), !!this.intro.length || void 0);
+    }
+    trimStart(rx) {
+        if (this.intro = this.intro.replace(rx, ''), this.intro.length) return !0;
+        let trimmed = this.content.replace(rx, '');
+        if (trimmed.length) {
+            if (trimmed !== this.content) {
+                let newChunk = this.split(this.end - trimmed.length);
+                this.edited && newChunk.edit(trimmed, this.storeName, !0), this.edit('', void 0, !0);
+            }
+            return !0;
+        }
+        if (this.edit('', void 0, !0), this.outro = this.outro.replace(rx, ''), this.outro.length) return !0;
+    }
+}
+let btoa = "u" > typeof globalThis && 'function' == typeof globalThis.btoa ? (str)=>globalThis.btoa(unescape(encodeURIComponent(str))) : 'function' == typeof Buffer ? (str)=>Buffer.from(str, 'utf-8').toString('base64') : ()=>{
+    throw Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+};
+class SourceMap {
+    constructor(properties){
+        this.version = 3, this.file = properties.file, this.sources = properties.sources, this.sourcesContent = properties.sourcesContent, this.names = properties.names, this.mappings = function(decoded) {
+            let writer = new StringWriter(), sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+            for(let i = 0; i < decoded.length; i++){
+                let line = decoded[i];
+                if (i > 0 && writer.write(59), 0 === line.length) continue;
+                let genColumn = 0;
+                for(let j = 0; j < line.length; j++){
+                    let segment = line[j];
+                    j > 0 && writer.write(44), genColumn = encodeInteger(writer, segment[0], genColumn), 1 !== segment.length && (sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex), sourceLine = encodeInteger(writer, segment[2], sourceLine), sourceColumn = encodeInteger(writer, segment[3], sourceColumn), 4 !== segment.length && (namesIndex = encodeInteger(writer, segment[4], namesIndex)));
+                }
+            }
+            return writer.flush();
+        }(properties.mappings), void 0 !== properties.x_google_ignoreList && (this.x_google_ignoreList = properties.x_google_ignoreList), void 0 !== properties.debugId && (this.debugId = properties.debugId);
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    toUrl() {
+        return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
+    }
+}
+let magic_string_es_toString = Object.prototype.toString;
+function getLocator(source) {
+    let originalLines = source.split('\n'), lineOffsets = [];
+    for(let i = 0, pos = 0; i < originalLines.length; i++)lineOffsets.push(pos), pos += originalLines[i].length + 1;
+    return function(index) {
+        let i = 0, j = lineOffsets.length;
+        for(; i < j;){
+            let m = i + j >> 1;
+            index < lineOffsets[m] ? j = m : i = m + 1;
+        }
+        let line = i - 1, column = index - lineOffsets[line];
+        return {
+            line,
+            column
+        };
+    };
+}
+let wordRegex = /\w/;
+class Mappings {
+    constructor(hires){
+        this.hires = hires, this.generatedCodeLine = 0, this.generatedCodeColumn = 0, this.raw = [], this.rawSegments = this.raw[this.generatedCodeLine] = [], this.pending = null;
+    }
+    addEdit(sourceIndex, content, loc, nameIndex) {
+        if (content.length) {
+            let contentLengthMinusOne = content.length - 1, contentLineEnd = content.indexOf('\n', 0), previousContentLineEnd = -1;
+            for(; contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd;){
+                let segment = [
+                    this.generatedCodeColumn,
+                    sourceIndex,
+                    loc.line,
+                    loc.column
+                ];
+                nameIndex >= 0 && segment.push(nameIndex), this.rawSegments.push(segment), this.generatedCodeLine += 1, this.raw[this.generatedCodeLine] = this.rawSegments = [], this.generatedCodeColumn = 0, previousContentLineEnd = contentLineEnd, contentLineEnd = content.indexOf('\n', contentLineEnd + 1);
+            }
+            let segment = [
+                this.generatedCodeColumn,
+                sourceIndex,
+                loc.line,
+                loc.column
+            ];
+            nameIndex >= 0 && segment.push(nameIndex), this.rawSegments.push(segment), this.advance(content.slice(previousContentLineEnd + 1));
+        } else this.pending && (this.rawSegments.push(this.pending), this.advance(content));
+        this.pending = null;
+    }
+    addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+        let originalCharIndex = chunk.start, first = !0, charInHiresBoundary = !1;
+        for(; originalCharIndex < chunk.end;){
+            if ('\n' === original[originalCharIndex]) loc.line += 1, loc.column = 0, this.generatedCodeLine += 1, this.raw[this.generatedCodeLine] = this.rawSegments = [], this.generatedCodeColumn = 0, first = !0, charInHiresBoundary = !1;
+            else {
+                if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
+                    let segment = [
+                        this.generatedCodeColumn,
+                        sourceIndex,
+                        loc.line,
+                        loc.column
+                    ];
+                    'boundary' === this.hires ? wordRegex.test(original[originalCharIndex]) ? charInHiresBoundary || (this.rawSegments.push(segment), charInHiresBoundary = !0) : (this.rawSegments.push(segment), charInHiresBoundary = !1) : this.rawSegments.push(segment);
+                }
+                loc.column += 1, this.generatedCodeColumn += 1, first = !1;
+            }
+            originalCharIndex += 1;
+        }
+        this.pending = null;
+    }
+    advance(str) {
+        if (!str) return;
+        let lines = str.split('\n');
+        if (lines.length > 1) {
+            for(let i = 0; i < lines.length - 1; i++)this.generatedCodeLine++, this.raw[this.generatedCodeLine] = this.rawSegments = [];
+            this.generatedCodeColumn = 0;
+        }
+        this.generatedCodeColumn += lines[lines.length - 1].length;
+    }
+}
+let warned = {
+    insertLeft: !1,
+    insertRight: !1,
+    storeName: !1
+};
+class MagicString {
+    constructor(string, options = {}){
+        let chunk = new Chunk(0, string.length, string);
+        Object.defineProperties(this, {
+            original: {
+                writable: !0,
+                value: string
+            },
+            outro: {
+                writable: !0,
+                value: ''
+            },
+            intro: {
+                writable: !0,
+                value: ''
+            },
+            firstChunk: {
+                writable: !0,
+                value: chunk
+            },
+            lastChunk: {
+                writable: !0,
+                value: chunk
+            },
+            lastSearchedChunk: {
+                writable: !0,
+                value: chunk
+            },
+            byStart: {
+                writable: !0,
+                value: {}
+            },
+            byEnd: {
+                writable: !0,
+                value: {}
+            },
+            filename: {
+                writable: !0,
+                value: options.filename
+            },
+            indentExclusionRanges: {
+                writable: !0,
+                value: options.indentExclusionRanges
+            },
+            sourcemapLocations: {
+                writable: !0,
+                value: new BitSet()
+            },
+            storedNames: {
+                writable: !0,
+                value: {}
+            },
+            indentStr: {
+                writable: !0,
+                value: void 0
+            },
+            ignoreList: {
+                writable: !0,
+                value: options.ignoreList
+            },
+            offset: {
+                writable: !0,
+                value: options.offset || 0
+            }
+        }), this.byStart[0] = chunk, this.byEnd[string.length] = chunk;
+    }
+    addSourcemapLocation(char) {
+        this.sourcemapLocations.add(char);
+    }
+    append(content) {
+        if ('string' != typeof content) throw TypeError('outro content must be a string');
+        return this.outro += content, this;
+    }
+    appendLeft(index, content) {
+        if (index += this.offset, 'string' != typeof content) throw TypeError('inserted content must be a string');
+        this._split(index);
+        let chunk = this.byEnd[index];
+        return chunk ? chunk.appendLeft(content) : this.intro += content, this;
+    }
+    appendRight(index, content) {
+        if (index += this.offset, 'string' != typeof content) throw TypeError('inserted content must be a string');
+        this._split(index);
+        let chunk = this.byStart[index];
+        return chunk ? chunk.appendRight(content) : this.outro += content, this;
+    }
+    clone() {
+        let cloned = new MagicString(this.original, {
+            filename: this.filename,
+            offset: this.offset
+        }), originalChunk = this.firstChunk, clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+        for(; originalChunk;){
+            cloned.byStart[clonedChunk.start] = clonedChunk, cloned.byEnd[clonedChunk.end] = clonedChunk;
+            let nextOriginalChunk = originalChunk.next, nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+            nextClonedChunk && (clonedChunk.next = nextClonedChunk, nextClonedChunk.previous = clonedChunk, clonedChunk = nextClonedChunk), originalChunk = nextOriginalChunk;
+        }
+        return cloned.lastChunk = clonedChunk, this.indentExclusionRanges && (cloned.indentExclusionRanges = this.indentExclusionRanges.slice()), cloned.sourcemapLocations = new BitSet(this.sourcemapLocations), cloned.intro = this.intro, cloned.outro = this.outro, cloned;
+    }
+    generateDecodedMap(options) {
+        options = options || {};
+        let names = Object.keys(this.storedNames), mappings = new Mappings(options.hires), locate = getLocator(this.original);
+        return this.intro && mappings.advance(this.intro), this.firstChunk.eachNext((chunk)=>{
+            let loc = locate(chunk.start);
+            chunk.intro.length && mappings.advance(chunk.intro), chunk.edited ? mappings.addEdit(0, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1) : mappings.addUneditedChunk(0, chunk, this.original, loc, this.sourcemapLocations), chunk.outro.length && mappings.advance(chunk.outro);
+        }), this.outro && mappings.advance(this.outro), {
+            file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+            sources: [
+                options.source ? function(from, to) {
+                    let fromParts = from.split(/[/\\]/), toParts = to.split(/[/\\]/);
+                    for(fromParts.pop(); fromParts[0] === toParts[0];)fromParts.shift(), toParts.shift();
+                    if (fromParts.length) {
+                        let i = fromParts.length;
+                        for(; i--;)fromParts[i] = '..';
+                    }
+                    return fromParts.concat(toParts).join('/');
+                }(options.file || '', options.source) : options.file || ''
+            ],
+            sourcesContent: options.includeContent ? [
+                this.original
+            ] : void 0,
+            names,
+            mappings: mappings.raw,
+            x_google_ignoreList: this.ignoreList ? [
+                0
+            ] : void 0
+        };
+    }
+    generateMap(options) {
+        return new SourceMap(this.generateDecodedMap(options));
+    }
+    _ensureindentStr() {
+        let lines, tabbed, spaced;
+        void 0 === this.indentStr && (this.indentStr = (tabbed = (lines = this.original.split('\n')).filter((line)=>/^\t+/.test(line)), spaced = lines.filter((line)=>/^ {2,}/.test(line)), 0 === tabbed.length && 0 === spaced.length ? null : tabbed.length >= spaced.length ? '\t' : Array(spaced.reduce((previous, current)=>Math.min(/^ +/.exec(current)[0].length, previous), 1 / 0) + 1).join(' ')));
+    }
+    _getRawIndentString() {
+        return this._ensureindentStr(), this.indentStr;
+    }
+    getIndentString() {
+        return this._ensureindentStr(), null === this.indentStr ? '\t' : this.indentStr;
+    }
+    indent(indentStr, options) {
+        var thing;
+        let pattern = /^[^\r\n]/gm;
+        if (thing = indentStr, '[object Object]' === magic_string_es_toString.call(thing) && (options = indentStr, indentStr = void 0), void 0 === indentStr && (this._ensureindentStr(), indentStr = this.indentStr || '\t'), '' === indentStr) return this;
+        let isExcluded = {};
+        (options = options || {}).exclude && ('number' == typeof options.exclude[0] ? [
+            options.exclude
+        ] : options.exclude).forEach((exclusion)=>{
+            for(let i = exclusion[0]; i < exclusion[1]; i += 1)isExcluded[i] = !0;
+        });
+        let shouldIndentNextCharacter = !1 !== options.indentStart, replacer = (match)=>shouldIndentNextCharacter ? `${indentStr}${match}` : (shouldIndentNextCharacter = !0, match);
+        this.intro = this.intro.replace(pattern, replacer);
+        let charIndex = 0, chunk = this.firstChunk;
+        for(; chunk;){
+            let end = chunk.end;
+            if (chunk.edited) !isExcluded[charIndex] && (chunk.content = chunk.content.replace(pattern, replacer), chunk.content.length && (shouldIndentNextCharacter = '\n' === chunk.content[chunk.content.length - 1]));
+            else for(charIndex = chunk.start; charIndex < end;){
+                if (!isExcluded[charIndex]) {
+                    let char = this.original[charIndex];
+                    '\n' === char ? shouldIndentNextCharacter = !0 : '\r' !== char && shouldIndentNextCharacter && (shouldIndentNextCharacter = !1, charIndex === chunk.start ? chunk.prependRight(indentStr) : (this._splitChunk(chunk, charIndex), (chunk = chunk.next).prependRight(indentStr)));
+                }
+                charIndex += 1;
+            }
+            charIndex = chunk.end, chunk = chunk.next;
+        }
+        return this.outro = this.outro.replace(pattern, replacer), this;
+    }
+    insert() {
+        throw Error('magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)');
+    }
+    insertLeft(index, content) {
+        return warned.insertLeft || (console.warn('magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead'), warned.insertLeft = !0), this.appendLeft(index, content);
+    }
+    insertRight(index, content) {
+        return warned.insertRight || (console.warn('magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead'), warned.insertRight = !0), this.prependRight(index, content);
+    }
+    move(start, end, index) {
+        if (start += this.offset, end += this.offset, (index += this.offset) >= start && index <= end) throw Error('Cannot move a selection inside itself');
+        this._split(start), this._split(end), this._split(index);
+        let first = this.byStart[start], last = this.byEnd[end], oldLeft = first.previous, oldRight = last.next, newRight = this.byStart[index];
+        if (!newRight && last === this.lastChunk) return this;
+        let newLeft = newRight ? newRight.previous : this.lastChunk;
+        return oldLeft && (oldLeft.next = oldRight), oldRight && (oldRight.previous = oldLeft), newLeft && (newLeft.next = first), newRight && (newRight.previous = last), first.previous || (this.firstChunk = last.next), last.next || (this.lastChunk = first.previous, this.lastChunk.next = null), first.previous = newLeft, last.next = newRight || null, newLeft || (this.firstChunk = first), newRight || (this.lastChunk = last), this;
+    }
+    overwrite(start, end, content, options) {
+        return options = options || {}, this.update(start, end, content, {
+            ...options,
+            overwrite: !options.contentOnly
+        });
+    }
+    update(start, end, content, options) {
+        if (start += this.offset, end += this.offset, 'string' != typeof content) throw TypeError('replacement content must be a string');
+        if (0 !== this.original.length) {
+            for(; start < 0;)start += this.original.length;
+            for(; end < 0;)end += this.original.length;
+        }
+        if (end > this.original.length) throw Error('end is out of bounds');
+        if (start === end) throw Error('Cannot overwrite a zero-length range – use appendLeft or prependRight instead');
+        this._split(start), this._split(end), !0 === options && (warned.storeName || (console.warn('The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string'), warned.storeName = !0), options = {
+            storeName: !0
+        });
+        let storeName = void 0 !== options && options.storeName, overwrite = void 0 !== options && options.overwrite;
+        if (storeName) {
+            let original = this.original.slice(start, end);
+            Object.defineProperty(this.storedNames, original, {
+                writable: !0,
+                value: !0,
+                enumerable: !0
+            });
+        }
+        let first = this.byStart[start], last = this.byEnd[end];
+        if (first) {
+            let chunk = first;
+            for(; chunk !== last;){
+                if (chunk.next !== this.byStart[chunk.end]) throw Error('Cannot overwrite across a split point');
+                (chunk = chunk.next).edit('', !1);
+            }
+            first.edit(content, storeName, !overwrite);
+        } else {
+            let newChunk = new Chunk(start, end, '').edit(content, storeName);
+            last.next = newChunk, newChunk.previous = last;
+        }
+        return this;
+    }
+    prepend(content) {
+        if ('string' != typeof content) throw TypeError('outro content must be a string');
+        return this.intro = content + this.intro, this;
     }
-    return trimmed;
-}, SPECIAL_NO_ENTRY_DEPS = [
-    '@iconify-icons/material-symbols'
-], FRAMEWORKS = [
-    'react',
-    'react-dom',
-    'react-router-dom',
-    'vue',
-    'vue-router'
-], getExternalLibraryName = (pkgName)=>{
-    let externalAlias = {
-        'react-dom': 'ReactDOM',
-        'react-router-dom': 'ReactRouterDOM'
-    };
-    return externalAlias[pkgName] ? externalAlias[pkgName] : pkgName.replace(/^@/, '').split(/[/\-.]/).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
-}, getExternalValue = (pkgName)=>`window ${getExternalLibraryName(pkgName)}`, MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, normalizeSvg = (content)=>content.replace(/<\?xml[\s\S]*?\?>/gi, '').replace(/<!DOCTYPE[\s\S]*?>/gi, '').replace(/<!--[\s\S]*?-->/g, '').trim(), extractSvgContent = (content)=>{
-    let match = content.match(/<svg\b([^>]*)>/i), viewBoxMatch = match?.[1]?.match(/viewBox\s*=\s*["']([^"']+)["']/i);
-    return {
-        inner: content.replace(/^[\s\S]*?<svg\b[^>]*>/i, '').replace(/<\/svg>[\s\S]*$/i, '').trim(),
-        viewBox: viewBoxMatch?.[1]
-    };
-}, readSvgFiles = (dir, collected = [])=>{
-    if (!node_fs.existsSync(dir)) return collected;
-    for (let entry of node_fs.readdirSync(dir, {
-        withFileTypes: !0
-    })){
-        let fullPath = node_path.join(dir, entry.name);
-        entry.isDirectory() ? readSvgFiles(fullPath, collected) : entry.isFile() && entry.name.toLowerCase().endsWith('.svg') && collected.push(fullPath);
+    prependLeft(index, content) {
+        if (index += this.offset, 'string' != typeof content) throw TypeError('inserted content must be a string');
+        this._split(index);
+        let chunk = this.byEnd[index];
+        return chunk ? chunk.prependLeft(content) : this.intro = content + this.intro, this;
     }
-    return collected;
-}, toSymbolId = (filePath, iconDir, symbolId)=>{
-    let relative = node_path.relative(iconDir, filePath), parsed = node_path.parse(relative), dir = parsed.dir.split(node_path.sep).filter(Boolean).join('-'), name = parsed.name;
-    if ('function' == typeof symbolId) return symbolId(name, filePath);
-    let id = (symbolId || 'icon-[dir]-[name]').replace(/\[name\]/g, name).replace(/\[dir\]/g, dir);
-    return id.replace(/--+/g, '-').replace(/^-+|-+$/g, '');
-}, BROWSERSLIST_CONFIG_FILES = [
-    '.browserslistrc',
-    '.browserslistrc.json',
-    '.browserslistrc.yaml',
-    '.browserslistrc.yml',
-    'browserslist',
-    'browserslist.config.js',
-    'browserslist.config.cjs',
-    'browserslist.config.mjs'
-], dist = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js");
+    prependRight(index, content) {
+        if (index += this.offset, 'string' != typeof content) throw TypeError('inserted content must be a string');
+        this._split(index);
+        let chunk = this.byStart[index];
+        return chunk ? chunk.prependRight(content) : this.outro = content + this.outro, this;
+    }
+    remove(start, end) {
+        if (start += this.offset, end += this.offset, 0 !== this.original.length) {
+            for(; start < 0;)start += this.original.length;
+            for(; end < 0;)end += this.original.length;
+        }
+        if (start === end) return this;
+        if (start < 0 || end > this.original.length) throw Error('Character is out of bounds');
+        if (start > end) throw Error('end must be greater than start');
+        this._split(start), this._split(end);
+        let chunk = this.byStart[start];
+        for(; chunk;)chunk.intro = '', chunk.outro = '', chunk.edit(''), chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        return this;
+    }
+    reset(start, end) {
+        if (start += this.offset, end += this.offset, 0 !== this.original.length) {
+            for(; start < 0;)start += this.original.length;
+            for(; end < 0;)end += this.original.length;
+        }
+        if (start === end) return this;
+        if (start < 0 || end > this.original.length) throw Error('Character is out of bounds');
+        if (start > end) throw Error('end must be greater than start');
+        this._split(start), this._split(end);
+        let chunk = this.byStart[start];
+        for(; chunk;)chunk.reset(), chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        return this;
+    }
+    lastChar() {
+        if (this.outro.length) return this.outro[this.outro.length - 1];
+        let chunk = this.lastChunk;
+        do {
+            if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+            if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+            if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+        }while (chunk = chunk.previous);
+        return this.intro.length ? this.intro[this.intro.length - 1] : '';
+    }
+    lastLine() {
+        let lineIndex = this.outro.lastIndexOf('\n');
+        if (-1 !== lineIndex) return this.outro.substr(lineIndex + 1);
+        let lineStr = this.outro, chunk = this.lastChunk;
+        do {
+            if (chunk.outro.length > 0) {
+                if (-1 !== (lineIndex = chunk.outro.lastIndexOf('\n'))) return chunk.outro.substr(lineIndex + 1) + lineStr;
+                lineStr = chunk.outro + lineStr;
+            }
+            if (chunk.content.length > 0) {
+                if (-1 !== (lineIndex = chunk.content.lastIndexOf('\n'))) return chunk.content.substr(lineIndex + 1) + lineStr;
+                lineStr = chunk.content + lineStr;
+            }
+            if (chunk.intro.length > 0) {
+                if (-1 !== (lineIndex = chunk.intro.lastIndexOf('\n'))) return chunk.intro.substr(lineIndex + 1) + lineStr;
+                lineStr = chunk.intro + lineStr;
+            }
+        }while (chunk = chunk.previous);
+        return -1 !== (lineIndex = this.intro.lastIndexOf('\n')) ? this.intro.substr(lineIndex + 1) + lineStr : this.intro + lineStr;
+    }
+    slice(start = 0, end = this.original.length - this.offset) {
+        if (start += this.offset, end += this.offset, 0 !== this.original.length) {
+            for(; start < 0;)start += this.original.length;
+            for(; end < 0;)end += this.original.length;
+        }
+        let result = '', chunk = this.firstChunk;
+        for(; chunk && (chunk.start > start || chunk.end <= start);){
+            if (chunk.start < end && chunk.end >= end) return result;
+            chunk = chunk.next;
+        }
+        if (chunk && chunk.edited && chunk.start !== start) throw Error(`Cannot use replaced character ${start} as slice start anchor.`);
+        let startChunk = chunk;
+        for(; chunk;){
+            chunk.intro && (startChunk !== chunk || chunk.start === start) && (result += chunk.intro);
+            let containsEnd = chunk.start < end && chunk.end >= end;
+            if (containsEnd && chunk.edited && chunk.end !== end) throw Error(`Cannot use replaced character ${end} as slice end anchor.`);
+            let sliceStart = startChunk === chunk ? start - chunk.start : 0, sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+            if (result += chunk.content.slice(sliceStart, sliceEnd), chunk.outro && (!containsEnd || chunk.end === end) && (result += chunk.outro), containsEnd) break;
+            chunk = chunk.next;
+        }
+        return result;
+    }
+    snip(start, end) {
+        let clone = this.clone();
+        return clone.remove(0, start), clone.remove(end, clone.original.length), clone;
+    }
+    _split(index) {
+        if (this.byStart[index] || this.byEnd[index]) return;
+        let chunk = this.lastSearchedChunk, previousChunk = chunk, searchForward = index > chunk.end;
+        for(; chunk;){
+            if (chunk.contains(index)) return this._splitChunk(chunk, index);
+            if ((chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start]) === previousChunk) return;
+            previousChunk = chunk;
+        }
+    }
+    _splitChunk(chunk, index) {
+        if (chunk.edited && chunk.content.length) {
+            let loc = getLocator(this.original)(index);
+            throw Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+        }
+        let newChunk = chunk.split(index);
+        return this.byEnd[index] = chunk, this.byStart[index] = newChunk, this.byEnd[newChunk.end] = newChunk, chunk === this.lastChunk && (this.lastChunk = newChunk), this.lastSearchedChunk = chunk, !0;
+    }
+    toString() {
+        let str = this.intro, chunk = this.firstChunk;
+        for(; chunk;)str += chunk.toString(), chunk = chunk.next;
+        return str + this.outro;
+    }
+    isEmpty() {
+        let chunk = this.firstChunk;
+        do if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return !1;
+        while (chunk = chunk.next);
+        return !0;
+    }
+    length() {
+        let chunk = this.firstChunk, length = 0;
+        do length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+        while (chunk = chunk.next);
+        return length;
+    }
+    trimLines() {
+        return this.trim('[\\r\\n]');
+    }
+    trim(charType) {
+        return this.trimStart(charType).trimEnd(charType);
+    }
+    trimEndAborted(charType) {
+        let rx = RegExp((charType || '\\s') + '+$');
+        if (this.outro = this.outro.replace(rx, ''), this.outro.length) return !0;
+        let chunk = this.lastChunk;
+        do {
+            let end = chunk.end, aborted = chunk.trimEnd(rx);
+            if (chunk.end !== end && (this.lastChunk === chunk && (this.lastChunk = chunk.next), this.byEnd[chunk.end] = chunk, this.byStart[chunk.next.start] = chunk.next, this.byEnd[chunk.next.end] = chunk.next), aborted) return !0;
+            chunk = chunk.previous;
+        }while (chunk);
+        return !1;
+    }
+    trimEnd(charType) {
+        return this.trimEndAborted(charType), this;
+    }
+    trimStartAborted(charType) {
+        let rx = RegExp('^' + (charType || '\\s') + '+');
+        if (this.intro = this.intro.replace(rx, ''), this.intro.length) return !0;
+        let chunk = this.firstChunk;
+        do {
+            let end = chunk.end, aborted = chunk.trimStart(rx);
+            if (chunk.end !== end && (chunk === this.lastChunk && (this.lastChunk = chunk.next), this.byEnd[chunk.end] = chunk, this.byStart[chunk.next.start] = chunk.next, this.byEnd[chunk.next.end] = chunk.next), aborted) return !0;
+            chunk = chunk.next;
+        }while (chunk);
+        return !1;
+    }
+    trimStart(charType) {
+        return this.trimStartAborted(charType), this;
+    }
+    hasChanged() {
+        return this.original !== this.toString();
+    }
+    _replaceRegexp(searchValue, replacement) {
+        function getReplacement(match, str) {
+            return 'string' == typeof replacement ? replacement.replace(/\$(\$|&|\d+)/g, (_, i)=>'$' === i ? '$' : '&' === i ? match[0] : +i < match.length ? match[+i] : `$${i}`) : replacement(...match, match.index, str, match.groups);
+        }
+        if (searchValue.global) (function(re, str) {
+            let match, matches = [];
+            for(; match = re.exec(str);)matches.push(match);
+            return matches;
+        })(searchValue, this.original).forEach((match)=>{
+            if (null != match.index) {
+                let replacement = getReplacement(match, this.original);
+                replacement !== match[0] && this.overwrite(match.index, match.index + match[0].length, replacement);
+            }
+        });
+        else {
+            let match = this.original.match(searchValue);
+            if (match && null != match.index) {
+                let replacement = getReplacement(match, this.original);
+                replacement !== match[0] && this.overwrite(match.index, match.index + match[0].length, replacement);
+            }
+        }
+        return this;
+    }
+    _replaceString(string, replacement) {
+        let { original } = this, index = original.indexOf(string);
+        return -1 !== index && ('function' == typeof replacement && (replacement = replacement(string, index, original)), string !== replacement && this.overwrite(index, index + string.length, replacement)), this;
+    }
+    replace(searchValue, replacement) {
+        return 'string' == typeof searchValue ? this._replaceString(searchValue, replacement) : this._replaceRegexp(searchValue, replacement);
+    }
+    _replaceAllString(string, replacement) {
+        let { original } = this, stringLength = string.length;
+        for(let index = original.indexOf(string); -1 !== index; index = original.indexOf(string, index + stringLength)){
+            let previous = original.slice(index, index + stringLength), _replacement = replacement;
+            'function' == typeof replacement && (_replacement = replacement(previous, index, original)), previous !== _replacement && this.overwrite(index, index + stringLength, _replacement);
+        }
+        return this;
+    }
+    replaceAll(searchValue, replacement) {
+        if ('string' == typeof searchValue) return this._replaceAllString(searchValue, replacement);
+        if (!searchValue.global) throw TypeError('MagicString.prototype.replaceAll called with a non-global RegExp argument');
+        return this._replaceRegexp(searchValue, replacement);
+    }
+}
+Object.prototype.hasOwnProperty;
+let dist = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js");
 var dist_default = __webpack_require__.n(dist), dist_default_0 = dist_default();
 let UNOCSS_CONFIG_FILES = [
     'unocss.config.mjs',
@@ -1774,7 +4464,65 @@ let UNOCSS_CONFIG_FILES = [
     if (!view) return (css)=>css;
     let prefix = {};
     return view.trim().replace(/(\\*)\\(["'`\\])/g, (_, bs, char)=>(prefix[char] = bs.replace(/\\\\/g, '\\'), '')), (css)=>css.replace(/["'`\\]/g, (v)=>(prefix[v] || '') + v);
-}, DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm, TRANSFORM_TIMING_STORE = Symbol.for('unpack:transformTimingMap'), PLUGIN_CONTEXT_STORE = Symbol.for('unpack:pluginContextStore'), globalScope = globalThis;
+}, main_0 = __webpack_require__("../../node_modules/.pnpm/dotenv-expand@12.0.3/node_modules/dotenv-expand/lib/main.js"), DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm, isIpv6LinkLocal = (address)=>address.toLowerCase().startsWith('fe80:'), checkPortOnHost = (port, host)=>new Promise((resolve)=>{
+        let server = node_net.createServer();
+        server.once('error', (error)=>{
+            'EADDRINUSE' === error.code ? resolve('occupied') : resolve('unsupported');
+        }), server.listen(null === host ? {
+            port,
+            exclusive: !0
+        } : {
+            port,
+            host,
+            exclusive: !0
+        }, ()=>{
+            server.close(()=>{
+                resolve('available');
+            });
+        });
+    }), getPortAvailability = async (port, hosts)=>{
+    let hasSupportedHost = !1;
+    for (let currentHost of hosts){
+        let result = await checkPortOnHost(port, currentHost);
+        if ('occupied' === result) return !1;
+        'available' === result && (hasSupportedHost = !0);
+    }
+    return hasSupportedHost;
+}, getRandomPort = async ()=>new Promise((resolve, reject)=>{
+        let server = node_net.createServer();
+        server.once('error', reject), server.listen({
+            port: 0,
+            exclusive: !0
+        }, ()=>{
+            let address = server.address(), resolvedPort = 'object' == typeof address && address ? address.port : 0;
+            server.close((error)=>{
+                error ? reject(error) : resolvedPort > 0 ? resolve(resolvedPort) : reject(Error('Failed to resolve random available port'));
+            });
+        });
+    }), getPort = async (startPort = 45678)=>{
+    let rawStartPort = Number.isFinite(startPort) ? Math.floor(startPort) : 45678;
+    if (0 === rawStartPort) return getRandomPort();
+    let normalizedStartPort = Math.max(1, Math.min(65535, rawStartPort)), hosts = (()=>{
+        let hosts = [
+            '0.0.0.0'
+        ];
+        try {
+            let interfaces = node_os.networkInterfaces();
+            for (let interfaceName of Object.keys(interfaces)){
+                let infos = interfaces[interfaceName];
+                if (infos) for (let info of infos){
+                    if (!info?.address) continue;
+                    let family = info.family;
+                    ('IPv6' === family || 6 === family) && isIpv6LinkLocal(info.address) || hosts.push(info.address);
+                }
+            }
+        } catch  {}
+        return hosts.push(null), Array.from(new Set(hosts));
+    })();
+    for(let port = normalizedStartPort; port <= 65535; port++)if (await getPortAvailability(port, hosts)) return port;
+    for(let port = 1; port < normalizedStartPort; port++)if (await getPortAvailability(port, hosts)) return port;
+    throw Error('No available port found');
+}, TRANSFORM_TIMING_STORE = Symbol.for('unpack:transformTimingMap'), PLUGIN_CONTEXT_STORE = Symbol.for('unpack:pluginContextStore'), globalScope = globalThis;
 globalScope[TRANSFORM_TIMING_STORE] ??= new WeakMap(), globalScope[PLUGIN_CONTEXT_STORE] ??= new WeakMap();
 let flattenUnpackPlugins = ()=>getCurrentUnpackConfig().plugins?.flat(1 / 0) || [];
 function getNormalizedPluginsByHook(hook) {
@@ -1868,7 +4616,7 @@ function applyPluginsByHookSync(hook, runner) {
 }
 async function getEntry(root, customEntry) {
     let entry;
-    if (entry = customEntry ? node_path.resolve(root, customEntry) : (await external_tinyglobby_glob('(index|main).{js,ts,jsx,tsx}', {
+    if (entry = customEntry ? node_path.resolve(root, customEntry) : (await dist_glob('(index|main).{js,ts,jsx,tsx}', {
         cwd: node_path.join(root, 'src'),
         absolute: !0
     }))[0], !node_fs.existsSync(entry)) throw Error('could not find entry file');
@@ -1920,7 +4668,7 @@ class JsMinifyPlugin {
     apply(compiler) {
         let meta = JSON.stringify({
             name: jsMinify_PLUGIN_NAME,
-            version: "4.7.2",
+            version: "4.7.4",
             options: this.minifyOptions
         });
         compiler.hooks.compilation.tap(jsMinify_PLUGIN_NAME, (compilation)=>{
@@ -2174,7 +4922,7 @@ async function getRspackConfig(originalUnpackConfig) {
             }
             return obj;
         }(node_fs.readFileSync(envPath)));
-        parsed.NODE_ENV && (processEnv.NODE_ENV = parsed.NODE_ENV), expand({
+        parsed.NODE_ENV && (processEnv.NODE_ENV = parsed.NODE_ENV), (0, main_0.expand)({
             parsed,
             processEnv
         });
@@ -2347,13 +5095,13 @@ async function getRspackConfig(originalUnpackConfig) {
             type: 'css',
             hash: unpackConfig.build?.filenameHash,
             async: !0
-        }), set(config, [
+        }), utils_set(config, [
             'module',
             'parser',
             'css/module'
         ], {
             namedExports: !1
-        }), set(config, [
+        }), utils_set(config, [
             'module',
             'generator',
             'css/module'
@@ -2654,12 +5402,12 @@ async function unpackDev(originalConfig) {
             ...middlewares
         ]);
     let server = new RspackDevServer(devServerOptions, compiler);
-    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v4.7.2`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
+    await server.start(), logger_logger.greet(`  ${colors.brand(`${colors.bold(unpackConfig._context.callerName.toUpperCase())} v4.7.4`)}  ${colors.dim('ready in')} ${colors.bold(Math.ceil(performance.now() - getUnpackStartTime()))} ${colors.dim('ms')}\n`), printServerUrls({
         port,
         host: unpackConfig.server.host,
         base: unpackConfig.base
     }), addRestartCleaner(()=>server.stop(), ()=>new Promise((resolve)=>compiler.close(()=>resolve())));
-    let open = unpackConfig.server?.open, url = isString(open) ? open : `http://localhost:${port}${devPublicPath}`;
+    let open = unpackConfig.server?.open, url = utils_isString(open) ? open : `http://localhost:${port}${devPublicPath}`;
     return open && openBrowser(url), {
         port,
         url
@@ -2668,7 +5416,7 @@ async function unpackDev(originalConfig) {
 function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'unpack' }) {
     let _context = {
         callerName,
-        version: "4.7.2",
+        version: "4.7.4",
         cachePath: 'node_modules/.unpack'
     }, resolveConfig = (mode)=>{
         let rootPath, outputPath, basePath, cachedTraceMap, fs, isValidMethodName, parseFrame, formatOriginalLocation, formatFullStack, resolveErrorLocationAndStack, root, alias, shouldTransformDeepImport, preJsAssets, jsAssets, cssAssets, bundledDepsCachePath, deepImportPkgPattern, deepImportRegex, plugin, tsconfigPath, root1, uno, generated, configOrPath, defaults, VIRTUAL_UNO_CSS_ID, rootDir, isMpa, unoConfig, configFilePath, unpackConfigPath, tokens, requestedLayers, tasks, unocssCacheDir, tokensCachePath, layersCachePath, timeCachePath, configHashCachePath, generatedCachePath, bundlerCacheDir, cachedTokensSize, cachedLayersSize, isCompiling, resolveUnocssConfig, flushTasks, getVirtualModuleContent, hash, restoreSkipCode, applyUnoTransformers, options, rootPath1, registerCode, namesCode, defaultConfig = {
@@ -2735,7 +5483,64 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                             if (!sourceMapContent) return;
                             tracer = new TraceMap(sourceMapContent), cachedTraceMap.set(sourceMapPath, tracer);
                         }
-                        let originalPosition = originalPositionFor(tracer, {
+                        let originalPosition = function(map, needle) {
+                            var map1, segments, memo, line, column, bias;
+                            let index, { line: line1, column: column1, bias: bias1 } = needle;
+                            if (--line1 < 0) throw Error("`line` must be greater than 0 (lines start at line 1)");
+                            if (column1 < 0) throw Error("`column` must be greater than or equal to 0 (columns start at column 0)");
+                            let decoded = (map1 = map)._decoded || (map1._decoded = function(mappings) {
+                                let { length } = mappings, reader = new StringReader(mappings), decoded = [], genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+                                do {
+                                    let semi = reader.indexOf(";"), line = [], sorted = !0, lastCol = 0;
+                                    for(genColumn = 0; reader.pos < semi;){
+                                        let seg;
+                                        (genColumn = decodeInteger(reader, genColumn)) < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), seg = hasMoreVlq(reader, semi) ? [
+                                            genColumn,
+                                            sourcesIndex,
+                                            sourceLine,
+                                            sourceColumn,
+                                            namesIndex = decodeInteger(reader, namesIndex)
+                                        ] : [
+                                            genColumn,
+                                            sourcesIndex,
+                                            sourceLine,
+                                            sourceColumn
+                                        ]) : seg = [
+                                            genColumn
+                                        ], line.push(seg), reader.pos++;
+                                    }
+                                    sorted || line.sort(sortComparator), decoded.push(line), reader.pos = semi + 1;
+                                }while (reader.pos <= length);
+                                return decoded;
+                            }(map1._encoded));
+                            if (line1 >= decoded.length) return OMapping(null, null, null, null);
+                            let segments1 = decoded[line1], index1 = (segments = segments1, memo = map._decodedMemo, line = line1, column = column1, bias = bias1 || 1, index = function(haystack, needle, state, key) {
+                                let { lastKey, lastNeedle, lastIndex } = state, low = 0, high = haystack.length - 1;
+                                if (key === lastKey) {
+                                    if (needle === lastNeedle) return found = -1 !== lastIndex && haystack[lastIndex][0] === needle, lastIndex;
+                                    needle >= lastNeedle ? low = -1 === lastIndex ? 0 : lastIndex : high = lastIndex;
+                                }
+                                return state.lastKey = key, state.lastNeedle = needle, state.lastIndex = function(haystack, needle, low, high) {
+                                    for(; low <= high;){
+                                        let mid = low + (high - low >> 1), cmp = haystack[mid][0] - needle;
+                                        if (0 === cmp) return found = !0, mid;
+                                        cmp < 0 ? low = mid + 1 : high = mid - 1;
+                                    }
+                                    return found = !1, low - 1;
+                                }(haystack, needle, low, high);
+                            }(segments, column, memo, line), (found ? index = (-1 === bias ? function(haystack, needle, index) {
+                                for(let i = index + 1; i < haystack.length && haystack[i][0] === needle; index = i++);
+                                return index;
+                            } : function(haystack, needle, index) {
+                                for(let i = index - 1; i >= 0 && haystack[i][0] === needle; index = i--);
+                                return index;
+                            })(segments, column, index) : -1 === bias && index++, -1 === index || index === segments.length) ? -1 : index);
+                            if (-1 === index1) return OMapping(null, null, null, null);
+                            let segment = segments1[index1];
+                            if (1 === segment.length) return OMapping(null, null, null, null);
+                            let { names, resolvedSources } = map;
+                            return OMapping(resolvedSources[segment[1]], segment[2] + 1, segment[3], 5 === segment.length ? names[segment[4]] : null);
+                        }(tracer, {
                             line: lineNumber,
                             column: column
                         });
@@ -2798,7 +5603,52 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                         locationSuffix: '',
                         stackString: ''
                     };
-                    let parsedFrames = parse(item.stack), userFrame = parsedFrames.find((frame)=>frame.file && null !== frame.lineNumber && null !== frame.column && SOURCE_REGEX.test(frame.file));
+                    let parsedFrames = item.stack.split('\n').reduce(function(stack, line) {
+                        var line1, parts, line2, parts1, line3, parts2, parseResult = function(line) {
+                            var parts = chromeRe.exec(line);
+                            if (!parts) return null;
+                            var isNative = parts[2] && 0 === parts[2].indexOf('native'), isEval = parts[2] && 0 === parts[2].indexOf('eval'), submatch = chromeEvalRe.exec(parts[2]);
+                            return isEval && null != submatch && (parts[2] = submatch[1], parts[3] = submatch[2], parts[4] = submatch[3]), {
+                                file: isNative ? null : parts[2],
+                                methodName: parts[1] || UNKNOWN_FUNCTION,
+                                arguments: isNative ? [
+                                    parts[2]
+                                ] : [],
+                                lineNumber: parts[3] ? +parts[3] : null,
+                                column: parts[4] ? +parts[4] : null
+                            };
+                        }(line) || (line1 = line, (parts = winjsRe.exec(line1)) ? {
+                            file: parts[2],
+                            methodName: parts[1] || UNKNOWN_FUNCTION,
+                            arguments: [],
+                            lineNumber: +parts[3],
+                            column: parts[4] ? +parts[4] : null
+                        } : null) || function(line) {
+                            var parts = geckoRe.exec(line);
+                            if (!parts) return null;
+                            var isEval = parts[3] && parts[3].indexOf(' > eval') > -1, submatch = geckoEvalRe.exec(parts[3]);
+                            return isEval && null != submatch && (parts[3] = submatch[1], parts[4] = submatch[2], parts[5] = null), {
+                                file: parts[3],
+                                methodName: parts[1] || UNKNOWN_FUNCTION,
+                                arguments: parts[2] ? parts[2].split(',') : [],
+                                lineNumber: parts[4] ? +parts[4] : null,
+                                column: parts[5] ? +parts[5] : null
+                            };
+                        }(line) || (line2 = line, (parts1 = nodeRe.exec(line2)) ? {
+                            file: parts1[2],
+                            methodName: parts1[1] || UNKNOWN_FUNCTION,
+                            arguments: [],
+                            lineNumber: +parts1[3],
+                            column: parts1[4] ? +parts1[4] : null
+                        } : null) || (line3 = line, (parts2 = javaScriptCoreRe.exec(line3)) ? {
+                            file: parts2[3],
+                            methodName: parts2[1] || UNKNOWN_FUNCTION,
+                            arguments: [],
+                            lineNumber: +parts2[4],
+                            column: parts2[5] ? +parts2[5] : null
+                        } : null);
+                        return parseResult && stack.push(parseResult), stack;
+                    }, []), userFrame = parsedFrames.find((frame)=>frame.file && null !== frame.lineNumber && null !== frame.column && SOURCE_REGEX.test(frame.file));
                     if (userFrame) {
                         let parsedUserFrame = await parseFrame(userFrame), loc = parsedUserFrame ? formatOriginalLocation(parsedUserFrame.originalPosition) : null;
                         if (loc) return {
@@ -2955,15 +5805,15 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                                             cleanedTemplate += `%${next}`, i++;
                                         }
                                         return [
-                                            format(cleanedTemplate, ...rest)
+                                            external_node_util_format(cleanedTemplate, ...rest)
                                         ];
                                     })(formattedArgs), prefix = colors.dim(`[browser ${time}]`);
                                     switch(level){
                                         case 'error':
-                                            console.log(colors.red(`${prefix} ${format(...outputArgs)}`));
+                                            console.log(colors.red(`${prefix} ${external_node_util_format(...outputArgs)}`));
                                             break;
                                         case 'warn':
-                                            console.log(colors.yellow(`${prefix} ${format(...outputArgs)}`));
+                                            console.log(colors.yellow(`${prefix} ${external_node_util_format(...outputArgs)}`));
                                             break;
                                         case 'debug':
                                             console.log(prefix, ...outputArgs);
@@ -3087,15 +5937,15 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                             let entry = ((packageJson)=>{
                                 if (packageJson.module) return packageJson.module;
                                 if (packageJson.exports) {
-                                    if (isString(packageJson.exports)) return packageJson.exports;
+                                    if (utils_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 (utils_isString(defaultExport)) return defaultExport;
+                                        if (utils_isString(defaultExport.import)) return defaultExport.import;
+                                        if (utils_isString(defaultExport.browser)) return defaultExport.browser;
+                                        if (utils_isString(defaultExport.default)) return defaultExport.default;
                                     }
-                                    if (isString(packageJson.exports.default)) return packageJson.exports.default;
+                                    if (utils_isString(packageJson.exports.default)) return packageJson.exports.default;
                                 }
                                 if (packageJson.main) return packageJson.main;
                             })(depPackageJson);
@@ -3500,7 +6350,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     LAYER_MARK_ALL
                 ]), tasks = [], unocssCacheDir = '', tokensCachePath = '', layersCachePath = '', timeCachePath = '', configHashCachePath = '', generatedCachePath = '', bundlerCacheDir = '', cachedTokensSize = 0, cachedLayersSize = 0, isCompiling = !0, resolveUnocssConfig = async ()=>{
                     let configFromOption = {};
-                    isPlainObject(configOrPath) ? configFromOption = configOrPath : isString(configOrPath) && (configFilePath = node_path.isAbsolute(configOrPath) ? configOrPath : node_path.resolve(rootDir, configOrPath)), configFilePath = ((root, customConfig)=>{
+                    isPlainObject(configOrPath) ? configFromOption = configOrPath : utils_isString(configOrPath) && (configFilePath = node_path.isAbsolute(configOrPath) ? configOrPath : node_path.resolve(rootDir, configOrPath)), configFilePath = ((root, customConfig)=>{
                         if (customConfig) {
                             let absPath = node_path.isAbsolute(customConfig) ? customConfig : node_path.resolve(root, customConfig);
                             if (node_fs.existsSync(absPath)) return absPath;
@@ -3532,7 +6382,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                     if (original.includes('@unocss-ignore')) return null;
                     let transformers = (uno.config.transformers || []).filter((i)=>(i.enforce || 'default') === enforce);
                     if (!transformers.length) return null;
-                    let skipMap = new Map(), code = original, s = new magic_string(((code, map, rules, keyFlag)=>{
+                    let skipMap = new Map(), code = original, s = new MagicString(((code, map, rules, keyFlag)=>{
                         let next = code;
                         for (let item of Array.from(next.matchAll(rules)))if (null != item) {
                             let matched = item[0], withHashKey = `${keyFlag}${hash(matched)}`;
@@ -3544,7 +6394,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
                         uno,
                         tokens,
                         invalidate: ()=>{}
-                    }), s.hasChanged() && (s = new magic_string(code = restoreSkipCode(s.toString(), skipMap))));
+                    }), s.hasChanged() && (s = new MagicString(code = restoreSkipCode(s.toString(), skipMap))));
                     return code !== original ? code : null;
                 }, {
                     name: 'unpack:unocss',
@@ -3746,7 +6596,7 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
             let mode = watch ? 'development' : 'production';
             setNodeEnv(mode);
             let config = resolveConfig(mode);
-            console.log(colors.brand(`${callerName} v4.7.2`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
+            console.log(colors.brand(`${callerName} v4.7.4`), colors.cyan(`building for ${mode}...`)), await unpackBuild(config);
         },
         dev: async ()=>{
             setUnpackStartTime(performance.now());
@@ -3761,14 +6611,1041 @@ function createUnpack({ cwd = process.cwd(), config: userConfig, callerName = 'u
         }
     };
 }
-let GLOB_REGEX = /[*?{}[\]()!@+|]/;
+let EntryTypes_FILE_TYPE = 'files', EntryTypes_DIR_TYPE = 'directories', EntryTypes_FILE_DIR_TYPE = 'files_directories', defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo)=>!0,
+    directoryFilter: (_entryInfo)=>!0,
+    type: EntryTypes_FILE_TYPE,
+    lstat: !1,
+    depth: 2147483648,
+    alwaysStat: !1,
+    highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+let RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR', NORMAL_FLOW_ERRORS = new Set([
+    'ENOENT',
+    'EPERM',
+    'EACCES',
+    'ELOOP',
+    RECURSIVE_ERROR_CODE
+]), ALL_TYPES = [
+    EntryTypes_DIR_TYPE,
+    'all',
+    EntryTypes_FILE_DIR_TYPE,
+    EntryTypes_FILE_TYPE
+], DIR_TYPES = new Set([
+    EntryTypes_DIR_TYPE,
+    'all',
+    EntryTypes_FILE_DIR_TYPE
+]), FILE_TYPES = new Set([
+    'all',
+    EntryTypes_FILE_DIR_TYPE,
+    EntryTypes_FILE_TYPE
+]), wantBigintFsStats = 'win32' === process.platform, emptyFn = (_entryInfo)=>!0, normalizeFilter = (filter)=>{
+    if (void 0 === filter) return emptyFn;
+    if ('function' == typeof filter) return filter;
+    if ('string' == typeof filter) {
+        let fl = filter.trim();
+        return (entry)=>entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        let trItems = filter.map((item)=>item.trim());
+        return (entry)=>trItems.some((f)=>entry.basename === f);
+    }
+    return emptyFn;
+};
+class ReaddirpStream extends Readable {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
+    constructor(options = {}){
+        super({
+            objectMode: !0,
+            autoDestroy: !0,
+            highWaterMark: options.highWaterMark
+        });
+        let opts = {
+            ...defaultOptions,
+            ...options
+        }, { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter), this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        let statMethod = opts.lstat ? lstat : promises_stat;
+        wantBigintFsStats ? this._stat = (path)=>statMethod(path, {
+                bigint: !0
+            }) : this._stat = statMethod, this._maxDepth = null != opts.depth && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth, this._wantsDir = !!type && DIR_TYPES.has(type), this._wantsFile = !!type && FILE_TYPES.has(type), this._wantsEverything = 'all' === type, this._root = external_node_path_resolve(root), this._isDirent = !opts.alwaysStat, this._statsProp = this._isDirent ? 'dirent' : 'stats', this._rdOptions = {
+            encoding: 'utf8',
+            withFileTypes: this._isDirent
+        }, this.parents = [
+            this._exploreDir(root, 1)
+        ], this.reading = !1, this.parent = void 0;
+    }
+    async _read(batch) {
+        if (!this.reading) {
+            this.reading = !0;
+            try {
+                for(; !this.destroyed && batch > 0;){
+                    let par = this.parent, fil = par && par.files;
+                    if (fil && fil.length > 0) {
+                        let { path, depth } = par, slice = fil.splice(0, batch).map((dirent)=>this._formatEntry(dirent, path));
+                        for (let entry of (await Promise.all(slice))){
+                            if (!entry) continue;
+                            if (this.destroyed) return;
+                            let entryType = await this._getEntryType(entry);
+                            'directory' === entryType && this._directoryFilter(entry) ? (depth <= this._maxDepth && this.parents.push(this._exploreDir(entry.fullPath, depth + 1)), this._wantsDir && (this.push(entry), batch--)) : ('file' === entryType || this._includeAsFile(entry)) && this._fileFilter(entry) && this._wantsFile && (this.push(entry), batch--);
+                        }
+                    } else {
+                        let parent = this.parents.pop();
+                        if (!parent) {
+                            this.push(null);
+                            break;
+                        }
+                        if (this.parent = await parent, this.destroyed) return;
+                    }
+                }
+            } catch (error) {
+                this.destroy(error);
+            } finally{
+                this.reading = !1;
+            }
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await readdir(path, this._rdOptions);
+        } catch (error) {
+            this._onError(error);
+        }
+        return {
+            files,
+            depth,
+            path
+        };
+    }
+    async _formatEntry(dirent, path) {
+        let entry, basename = this._isDirent ? dirent.name : dirent;
+        try {
+            let fullPath = external_node_path_resolve(join(path, basename));
+            (entry = {
+                path: external_node_path_relative(this._root, fullPath),
+                fullPath,
+                basename
+            })[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        } catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        NORMAL_FLOW_ERRORS.has(err.code) && !this.destroyed ? this.emit('warn', err) : this.destroy(err);
+    }
+    async _getEntryType(entry) {
+        if (!entry && this._statsProp in entry) return '';
+        let stats = entry[this._statsProp];
+        if (stats.isFile()) return 'file';
+        if (stats.isDirectory()) return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            let full = entry.fullPath;
+            try {
+                let entryRealPath = await promises_realpath(full), entryRealPathStats = await lstat(entryRealPath);
+                if (entryRealPathStats.isFile()) return 'file';
+                if (entryRealPathStats.isDirectory()) {
+                    let len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+                        let recursiveError = Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        return recursiveError.code = RECURSIVE_ERROR_CODE, this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            } catch (error) {
+                return this._onError(error), '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        let stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+let EMPTY_FN = ()=>{}, pl = process.platform, isWindows = 'win32' === pl, isMacos = 'darwin' === pl, isLinux = 'linux' === pl, isFreeBSD = 'freebsd' === pl, isIBMi = 'OS400' === external_node_os_type(), EVENTS_ALL = 'all', EVENTS_READY = 'ready', EVENTS_ADD = 'add', EVENTS_CHANGE = 'change', EVENTS_ADD_DIR = 'addDir', EVENTS_UNLINK = 'unlink', EVENTS_UNLINK_DIR = 'unlinkDir', EVENTS_RAW = 'raw', EVENTS_ERROR = 'error', statMethods = {
+    lstat: lstat,
+    stat: promises_stat
+}, KEY_LISTENERS = 'listeners', KEY_ERR = 'errHandlers', KEY_RAW = 'rawEmitters', HANDLER_KEYS = [
+    KEY_LISTENERS,
+    KEY_ERR,
+    KEY_RAW
+], binaryExtensions = new Set([
+    '3dm',
+    '3ds',
+    '3g2',
+    '3gp',
+    '7z',
+    'a',
+    'aac',
+    'adp',
+    'afdesign',
+    'afphoto',
+    'afpub',
+    'ai',
+    'aif',
+    'aiff',
+    'alz',
+    'ape',
+    'apk',
+    'appimage',
+    'ar',
+    'arj',
+    'asf',
+    'au',
+    'avi',
+    'bak',
+    'baml',
+    'bh',
+    'bin',
+    'bk',
+    'bmp',
+    'btif',
+    'bz2',
+    'bzip2',
+    'cab',
+    'caf',
+    'cgm',
+    'class',
+    'cmx',
+    'cpio',
+    'cr2',
+    'cur',
+    'dat',
+    'dcm',
+    'deb',
+    'dex',
+    'djvu',
+    'dll',
+    'dmg',
+    'dng',
+    'doc',
+    'docm',
+    'docx',
+    'dot',
+    'dotm',
+    'dra',
+    'DS_Store',
+    'dsk',
+    'dts',
+    'dtshd',
+    'dvb',
+    'dwg',
+    'dxf',
+    'ecelp4800',
+    'ecelp7470',
+    'ecelp9600',
+    'egg',
+    'eol',
+    'eot',
+    'epub',
+    'exe',
+    'f4v',
+    'fbs',
+    'fh',
+    'fla',
+    'flac',
+    'flatpak',
+    'fli',
+    'flv',
+    'fpx',
+    'fst',
+    'fvt',
+    'g3',
+    'gh',
+    'gif',
+    'graffle',
+    'gz',
+    'gzip',
+    'h261',
+    'h263',
+    'h264',
+    'icns',
+    'ico',
+    'ief',
+    'img',
+    'ipa',
+    'iso',
+    'jar',
+    'jpeg',
+    'jpg',
+    'jpgv',
+    'jpm',
+    'jxr',
+    'key',
+    'ktx',
+    'lha',
+    'lib',
+    'lvp',
+    'lz',
+    'lzh',
+    'lzma',
+    'lzo',
+    'm3u',
+    'm4a',
+    'm4v',
+    'mar',
+    'mdi',
+    'mht',
+    'mid',
+    'midi',
+    'mj2',
+    'mka',
+    'mkv',
+    'mmr',
+    'mng',
+    'mobi',
+    'mov',
+    'movie',
+    'mp3',
+    'mp4',
+    'mp4a',
+    'mpeg',
+    'mpg',
+    'mpga',
+    'mxu',
+    'nef',
+    'npx',
+    'numbers',
+    'nupkg',
+    'o',
+    'odp',
+    'ods',
+    'odt',
+    'oga',
+    'ogg',
+    'ogv',
+    'otf',
+    'ott',
+    'pages',
+    'pbm',
+    'pcx',
+    'pdb',
+    'pdf',
+    'pea',
+    'pgm',
+    'pic',
+    'png',
+    'pnm',
+    'pot',
+    'potm',
+    'potx',
+    'ppa',
+    'ppam',
+    'ppm',
+    'pps',
+    'ppsm',
+    'ppsx',
+    'ppt',
+    'pptm',
+    'pptx',
+    'psd',
+    'pya',
+    'pyc',
+    'pyo',
+    'pyv',
+    'qt',
+    'rar',
+    'ras',
+    'raw',
+    'resources',
+    'rgb',
+    'rip',
+    'rlc',
+    'rmf',
+    'rmvb',
+    'rpm',
+    'rtf',
+    'rz',
+    's3m',
+    's7z',
+    'scpt',
+    'sgi',
+    'shar',
+    'snap',
+    'sil',
+    'sketch',
+    'slk',
+    'smv',
+    'snk',
+    'so',
+    'stl',
+    'suo',
+    'sub',
+    'swf',
+    'tar',
+    'tbz',
+    'tbz2',
+    'tga',
+    'tgz',
+    'thmx',
+    'tif',
+    'tiff',
+    'tlz',
+    'ttc',
+    'ttf',
+    'txz',
+    'udf',
+    'uvh',
+    'uvi',
+    'uvm',
+    'uvp',
+    'uvs',
+    'uvu',
+    'viv',
+    'vob',
+    'war',
+    'wav',
+    'wax',
+    'wbmp',
+    'wdp',
+    'weba',
+    'webm',
+    'webp',
+    'whl',
+    'wim',
+    'wm',
+    'wma',
+    'wmv',
+    'wmx',
+    'woff',
+    'woff2',
+    'wrm',
+    'wvx',
+    'xbm',
+    'xif',
+    'xla',
+    'xlam',
+    'xls',
+    'xlsb',
+    'xlsm',
+    'xlsx',
+    'xlt',
+    'xltm',
+    'xltx',
+    'xm',
+    'xmind',
+    'xpi',
+    'xpm',
+    'xwd',
+    'xz',
+    'z',
+    'zip',
+    'zipx'
+]), foreach = (val, fn)=>{
+    val instanceof Set ? val.forEach(fn) : fn(val);
+}, addAndConvert = (main, prop, item)=>{
+    let container = main[prop];
+    container instanceof Set || (main[prop] = container = new Set([
+        container
+    ])), container.add(item);
+}, delFromSet = (main, prop, item)=>{
+    let container = main[prop];
+    container instanceof Set ? container.delete(item) : container === item && delete main[prop];
+}, isEmptySet = (val)=>val instanceof Set ? 0 === val.size : !val, FsWatchInstances = new Map();
+function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
+    try {
+        return external_node_fs_watch(path, {
+            persistent: options.persistent
+        }, (rawEvent, evPath)=>{
+            listener(path), emitRaw(rawEvent, evPath, {
+                watchedPath: path
+            }), evPath && path !== evPath && fsWatchBroadcast(external_node_path_resolve(path, evPath), KEY_LISTENERS, join(path, evPath));
+        });
+    } catch (error) {
+        errHandler(error);
+        return;
+    }
+}
+let fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3)=>{
+    let cont = FsWatchInstances.get(fullPath);
+    cont && foreach(cont[listenerType], (listener)=>{
+        listener(val1, val2, val3);
+    });
+}, FsWatchFileInstances = new Map();
+class NodeFsHandler {
+    fsw;
+    _boundHandleError;
+    constructor(fsW){
+        this.fsw = fsW, this._boundHandleError = (error)=>fsW._handleError(error);
+    }
+    _watchWithNodeFs(path, listener) {
+        let closer, opts = this.fsw.options, directory = external_node_path_dirname(path), basename = external_node_path_basename(path);
+        this.fsw._getWatchedDir(directory).add(basename);
+        let absolutePath = external_node_path_resolve(path), options = {
+            persistent: opts.persistent
+        };
+        if (listener || (listener = EMPTY_FN), opts.usePolling) options.interval = opts.interval !== opts.binaryInterval && binaryExtensions.has(extname(basename).slice(1).toLowerCase()) ? opts.binaryInterval : opts.interval, closer = ((path, fullPath, options, handlers)=>{
+            let { listener, rawEmitter } = handlers, cont = FsWatchFileInstances.get(fullPath), copts = cont && cont.options;
+            return copts && (copts.persistent < options.persistent || copts.interval > options.interval) && (unwatchFile(fullPath), cont = void 0), cont ? (addAndConvert(cont, KEY_LISTENERS, listener), addAndConvert(cont, KEY_RAW, rawEmitter)) : (cont = {
+                listeners: listener,
+                rawEmitters: rawEmitter,
+                options,
+                watcher: watchFile(fullPath, options, (curr, prev)=>{
+                    foreach(cont.rawEmitters, (rawEmitter)=>{
+                        rawEmitter(EVENTS_CHANGE, fullPath, {
+                            curr,
+                            prev
+                        });
+                    });
+                    let currmtime = curr.mtimeMs;
+                    (curr.size !== prev.size || currmtime > prev.mtimeMs || 0 === currmtime) && foreach(cont.listeners, (listener)=>listener(path, curr));
+                })
+            }, FsWatchFileInstances.set(fullPath, cont)), ()=>{
+                delFromSet(cont, KEY_LISTENERS, listener), delFromSet(cont, KEY_RAW, rawEmitter), isEmptySet(cont.listeners) && (FsWatchFileInstances.delete(fullPath), unwatchFile(fullPath), cont.options = cont.watcher = void 0, Object.freeze(cont));
+            };
+        })(path, absolutePath, options, {
+            listener,
+            rawEmitter: this.fsw._emitRaw
+        });
+        else closer = ((path, fullPath, options, handlers)=>{
+            let watcher, { listener, errHandler, rawEmitter } = handlers, cont = FsWatchInstances.get(fullPath);
+            if (!options.persistent) {
+                if (!(watcher = createFsWatchInstance(path, options, listener, errHandler, rawEmitter))) return;
+                return watcher.close.bind(watcher);
+            }
+            if (cont) addAndConvert(cont, KEY_LISTENERS, listener), addAndConvert(cont, KEY_ERR, errHandler), addAndConvert(cont, KEY_RAW, rawEmitter);
+            else {
+                if (!(watcher = createFsWatchInstance(path, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW)))) return;
+                watcher.on(EVENTS_ERROR, async (error)=>{
+                    let broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+                    if (cont && (cont.watcherUnusable = !0), isWindows && 'EPERM' === error.code) try {
+                        let fd = await promises_open(path, 'r');
+                        await fd.close(), broadcastErr(error);
+                    } catch (err) {}
+                    else broadcastErr(error);
+                }), cont = {
+                    listeners: listener,
+                    errHandlers: errHandler,
+                    rawEmitters: rawEmitter,
+                    watcher
+                }, FsWatchInstances.set(fullPath, cont);
+            }
+            return ()=>{
+                if (delFromSet(cont, KEY_LISTENERS, listener), delFromSet(cont, KEY_ERR, errHandler), delFromSet(cont, KEY_RAW, rawEmitter), isEmptySet(cont.listeners)) {
+                    let cont1;
+                    cont.watcher.close(), FsWatchInstances.delete(fullPath), HANDLER_KEYS.forEach((cont1 = cont, (key)=>{
+                        let set = cont1[key];
+                        set instanceof Set ? set.clear() : delete cont1[key];
+                    })), cont.watcher = void 0, Object.freeze(cont);
+                }
+            };
+        })(path, absolutePath, options, {
+            listener,
+            errHandler: this._boundHandleError,
+            rawEmitter: this.fsw._emitRaw
+        });
+        return closer;
+    }
+    _handleFile(file, stats, initialAdd) {
+        if (this.fsw.closed) return;
+        let dirname = external_node_path_dirname(file), basename = external_node_path_basename(file), parent = this.fsw._getWatchedDir(dirname), prevStats = stats;
+        if (parent.has(basename)) return;
+        let listener = async (path, newStats)=>{
+            if (this.fsw._throttle('watch', file, 5)) if (newStats && 0 !== newStats.mtimeMs) {
+                if (parent.has(basename)) {
+                    let at = newStats.atimeMs, mt = newStats.mtimeMs;
+                    (!at || at <= mt || mt !== prevStats.mtimeMs) && this.fsw._emit(EVENTS_CHANGE, file, newStats), prevStats = newStats;
+                }
+            } else try {
+                let newStats = await promises_stat(file);
+                if (this.fsw.closed) return;
+                let at = newStats.atimeMs, mt = newStats.mtimeMs;
+                if ((!at || at <= mt || mt !== prevStats.mtimeMs) && this.fsw._emit(EVENTS_CHANGE, file, newStats), (isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats.ino) {
+                    this.fsw._closeFile(path), prevStats = newStats;
+                    let closer = this._watchWithNodeFs(file, listener);
+                    closer && this.fsw._addPathCloser(path, closer);
+                } else prevStats = newStats;
+            } catch (error) {
+                this.fsw._remove(dirname, basename);
+            }
+        }, closer = this._watchWithNodeFs(file, listener);
+        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+            if (!this.fsw._throttle(EVENTS_ADD, file, 0)) return;
+            this.fsw._emit(EVENTS_ADD, file, stats);
+        }
+        return closer;
+    }
+    async _handleSymlink(entry, directory, path, item) {
+        if (this.fsw.closed) return;
+        let full = entry.fullPath, dir = this.fsw._getWatchedDir(directory);
+        if (!this.fsw.options.followSymlinks) {
+            let linkPath;
+            this.fsw._incrReadyCount();
+            try {
+                linkPath = await promises_realpath(path);
+            } catch (e) {
+                return this.fsw._emitReady(), !0;
+            }
+            if (this.fsw.closed) return;
+            return dir.has(item) ? this.fsw._symlinkPaths.get(full) !== linkPath && (this.fsw._symlinkPaths.set(full, linkPath), this.fsw._emit(EVENTS_CHANGE, path, entry.stats)) : (dir.add(item), this.fsw._symlinkPaths.set(full, linkPath), this.fsw._emit(EVENTS_ADD, path, entry.stats)), this.fsw._emitReady(), !0;
+        }
+        if (this.fsw._symlinkPaths.has(full)) return !0;
+        this.fsw._symlinkPaths.set(full, !0);
+    }
+    _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+        directory = join(directory, '');
+        let throttleKey = target ? `${directory}:${target}` : directory;
+        if (!(throttler = this.fsw._throttle('readdir', throttleKey, 1000))) return;
+        let previous = this.fsw._getWatchedDir(wh.path), current = new Set(), stream = this.fsw._readdirp(directory, {
+            fileFilter: (entry)=>wh.filterPath(entry),
+            directoryFilter: (entry)=>wh.filterDir(entry)
+        });
+        if (stream) return stream.on('data', async (entry)=>{
+            if (this.fsw.closed) {
+                stream = void 0;
+                return;
+            }
+            let item = entry.path, path = join(directory, item);
+            if (current.add(item), !(entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item))) {
+                if (this.fsw.closed) {
+                    stream = void 0;
+                    return;
+                }
+                item !== target && (target || previous.has(item)) || (this.fsw._incrReadyCount(), path = join(dir, external_node_path_relative(dir, path)), this._addToNodeFs(path, initialAdd, wh, depth + 1));
+            }
+        }).on(EVENTS_ERROR, this._boundHandleError), new Promise((resolve, reject)=>{
+            if (!stream) return reject();
+            stream.once('end', ()=>{
+                if (this.fsw.closed) {
+                    stream = void 0;
+                    return;
+                }
+                let wasThrottled = !!throttler && throttler.clear();
+                resolve(void 0), previous.getChildren().filter((item)=>item !== directory && !current.has(item)).forEach((item)=>{
+                    this.fsw._remove(directory, item);
+                }), stream = void 0, wasThrottled && this._handleRead(directory, !1, wh, target, dir, depth, throttler);
+            });
+        });
+    }
+    async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
+        let throttler, closer, parentDir = this.fsw._getWatchedDir(external_node_path_dirname(dir)), tracked = parentDir.has(external_node_path_basename(dir));
+        initialAdd && this.fsw.options.ignoreInitial || target || tracked || this.fsw._emit(EVENTS_ADD_DIR, dir, stats), parentDir.add(external_node_path_basename(dir)), this.fsw._getWatchedDir(dir);
+        let oDepth = this.fsw.options.depth;
+        if ((null == oDepth || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
+            if (!target && (await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler), this.fsw.closed)) return;
+            closer = this._watchWithNodeFs(dir, (dirPath, stats)=>{
+                stats && 0 === stats.mtimeMs || this._handleRead(dirPath, !1, wh, target, dir, depth, throttler);
+            });
+        }
+        return closer;
+    }
+    async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
+        let ready = this.fsw._emitReady;
+        if (this.fsw._isIgnored(path) || this.fsw.closed) return ready(), !1;
+        let wh = this.fsw._getWatchHelpers(path);
+        priorWh && (wh.filterPath = (entry)=>priorWh.filterPath(entry), wh.filterDir = (entry)=>priorWh.filterDir(entry));
+        try {
+            let closer, stats = await statMethods[wh.statMethod](wh.watchPath);
+            if (this.fsw.closed) return;
+            if (this.fsw._isIgnored(wh.watchPath, stats)) return ready(), !1;
+            let follow = this.fsw.options.followSymlinks;
+            if (stats.isDirectory()) {
+                let absPath = external_node_path_resolve(path), targetPath = follow ? await promises_realpath(path) : path;
+                if (this.fsw.closed || (closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath), this.fsw.closed)) return;
+                absPath !== targetPath && void 0 !== targetPath && this.fsw._symlinkPaths.set(absPath, targetPath);
+            } else if (stats.isSymbolicLink()) {
+                let targetPath = follow ? await promises_realpath(path) : path;
+                if (this.fsw.closed) return;
+                let parent = external_node_path_dirname(wh.watchPath);
+                if (this.fsw._getWatchedDir(parent).add(wh.watchPath), this.fsw._emit(EVENTS_ADD, wh.watchPath, stats), closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath), this.fsw.closed) return;
+                void 0 !== targetPath && this.fsw._symlinkPaths.set(external_node_path_resolve(path), targetPath);
+            } else closer = this._handleFile(wh.watchPath, stats, initialAdd);
+            return ready(), closer && this.fsw._addPathCloser(path, closer), !1;
+        } catch (error) {
+            if (this.fsw._handleError(error)) return ready(), path;
+        }
+    }
+}
+let BACK_SLASH_RE = /\\/g, DOUBLE_SLASH_RE = /\/\//g, DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/, REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+    return Array.isArray(item) ? item : [
+        item
+    ];
+}
+let isMatcherObject = (matcher)=>'object' == typeof matcher && null !== matcher && !(matcher instanceof RegExp);
+function chokidar_matchPatterns(patterns, testString, stats) {
+    let path = function(path) {
+        if ('string' != typeof path) throw Error('string expected');
+        path = (path = normalize(path)).replace(/\\/g, '/');
+        let prepend = !1;
+        return path.startsWith('//') && (prepend = !0), path = path.replace(DOUBLE_SLASH_RE, '/'), prepend && (path = '/' + path), path;
+    }(testString);
+    for(let index = 0; index < patterns.length; index++)if ((0, patterns[index])(path, stats)) return !0;
+    return !1;
+}
+let unifyPaths = (paths_)=>{
+    let paths = arrify(paths_).flat();
+    if (!paths.every((p)=>'string' == typeof p)) throw TypeError(`Non-string provided as watch path: ${paths}`);
+    return paths.map(normalizePathToUnix);
+}, toUnix = (string)=>{
+    let str = string.replace(BACK_SLASH_RE, '/'), prepend = !1;
+    return str.startsWith('//') && (prepend = !0), str = str.replace(DOUBLE_SLASH_RE, '/'), prepend && (str = '/' + str), str;
+}, normalizePathToUnix = (path)=>toUnix(normalize(toUnix(path))), normalizeIgnored = (cwd = '')=>(path)=>'string' == typeof path ? normalizePathToUnix(isAbsolute(path) ? path : join(cwd, path)) : path, EMPTY_SET = Object.freeze(new Set());
+class DirEntry {
+    path;
+    _removeWatcher;
+    items;
+    constructor(dir, removeWatcher){
+        this.path = dir, this._removeWatcher = removeWatcher, this.items = new Set();
+    }
+    add(item) {
+        let { items } = this;
+        items && '.' !== item && '..' !== item && items.add(item);
+    }
+    async remove(item) {
+        let { items } = this;
+        if (!items || (items.delete(item), items.size > 0)) return;
+        let dir = this.path;
+        try {
+            await readdir(dir);
+        } catch (err) {
+            this._removeWatcher && this._removeWatcher(external_node_path_dirname(dir), external_node_path_basename(dir));
+        }
+    }
+    has(item) {
+        let { items } = this;
+        if (items) return items.has(item);
+    }
+    getChildren() {
+        let { items } = this;
+        return items ? [
+            ...items.values()
+        ] : [];
+    }
+    dispose() {
+        this.items.clear(), this.path = '', this._removeWatcher = EMPTY_FN, this.items = EMPTY_SET, Object.freeze(this);
+    }
+}
+class WatchHelper {
+    fsw;
+    path;
+    watchPath;
+    fullWatchPath;
+    dirParts;
+    followSymlinks;
+    statMethod;
+    constructor(path, follow, fsw){
+        this.fsw = fsw;
+        let watchPath = path;
+        this.path = path = path.replace(REPLACER_RE, ''), this.watchPath = watchPath, this.fullWatchPath = external_node_path_resolve(watchPath), this.dirParts = [], this.dirParts.forEach((parts)=>{
+            parts.length > 1 && parts.pop();
+        }), this.followSymlinks = follow, this.statMethod = follow ? 'stat' : 'lstat';
+    }
+    entryPath(entry) {
+        return join(this.watchPath, external_node_path_relative(this.watchPath, entry.fullPath));
+    }
+    filterPath(entry) {
+        let { stats } = entry;
+        if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
+        let resolvedPath = this.entryPath(entry);
+        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+    }
+    filterDir(entry) {
+        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+    }
+}
+class FSWatcher extends EventEmitter {
+    closed;
+    options;
+    _closers;
+    _ignoredPaths;
+    _throttled;
+    _streams;
+    _symlinkPaths;
+    _watched;
+    _pendingWrites;
+    _pendingUnlinks;
+    _readyCount;
+    _emitReady;
+    _closePromise;
+    _userIgnored;
+    _readyEmitted;
+    _emitRaw;
+    _boundRemove;
+    _nodeFsHandler;
+    constructor(_opts = {}){
+        super(), this.closed = !1, this._closers = new Map(), this._ignoredPaths = new Set(), this._throttled = new Map(), this._streams = new Set(), this._symlinkPaths = new Map(), this._watched = new Map(), this._pendingWrites = new Map(), this._pendingUnlinks = new Map(), this._readyCount = 0, this._readyEmitted = !1;
+        let awf = _opts.awaitWriteFinish, DEF_AWF = {
+            stabilityThreshold: 2000,
+            pollInterval: 100
+        }, opts = {
+            persistent: !0,
+            ignoreInitial: !1,
+            ignorePermissionErrors: !1,
+            interval: 100,
+            binaryInterval: 300,
+            followSymlinks: !0,
+            usePolling: !1,
+            atomic: !0,
+            ..._opts,
+            ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+            awaitWriteFinish: !0 === awf ? DEF_AWF : 'object' == typeof awf && {
+                ...DEF_AWF,
+                ...awf
+            }
+        };
+        isIBMi && (opts.usePolling = !0), void 0 === opts.atomic && (opts.atomic = !opts.usePolling);
+        let envPoll = process.env.CHOKIDAR_USEPOLLING;
+        if (void 0 !== envPoll) {
+            let envLower = envPoll.toLowerCase();
+            'false' === envLower || '0' === envLower ? opts.usePolling = !1 : 'true' === envLower || '1' === envLower ? opts.usePolling = !0 : opts.usePolling = !!envLower;
+        }
+        let envInterval = process.env.CHOKIDAR_INTERVAL;
+        envInterval && (opts.interval = Number.parseInt(envInterval, 10));
+        let readyCalls = 0;
+        this._emitReady = ()=>{
+            ++readyCalls >= this._readyCount && (this._emitReady = EMPTY_FN, this._readyEmitted = !0, process.nextTick(()=>this.emit(EVENTS_READY)));
+        }, this._emitRaw = (...args)=>this.emit(EVENTS_RAW, ...args), this._boundRemove = this._remove.bind(this), this.options = opts, this._nodeFsHandler = new NodeFsHandler(this), Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+        if (isMatcherObject(matcher)) {
+            for (let ignored of this._ignoredPaths)if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) return;
+        }
+        this._ignoredPaths.add(matcher);
+    }
+    _removeIgnoredPath(matcher) {
+        if (this._ignoredPaths.delete(matcher), 'string' == typeof matcher) for (let ignored of this._ignoredPaths)isMatcherObject(ignored) && ignored.path === matcher && this._ignoredPaths.delete(ignored);
+    }
+    add(paths_, _origAdd, _internal) {
+        let { cwd } = this.options;
+        this.closed = !1, this._closePromise = void 0;
+        let paths = unifyPaths(paths_);
+        return cwd && (paths = paths.map((path)=>isAbsolute(path) ? path : join(cwd, path))), paths.forEach((path)=>{
+            this._removeIgnoredPath(path);
+        }), this._userIgnored = void 0, this._readyCount || (this._readyCount = 0), this._readyCount += paths.length, Promise.all(paths.map(async (path)=>{
+            let res = await this._nodeFsHandler._addToNodeFs(path, !_internal, void 0, 0, _origAdd);
+            return res && this._emitReady(), res;
+        })).then((results)=>{
+            this.closed || results.forEach((item)=>{
+                item && this.add(external_node_path_dirname(item), external_node_path_basename(_origAdd || item));
+            });
+        }), this;
+    }
+    unwatch(paths_) {
+        if (this.closed) return this;
+        let paths = unifyPaths(paths_), { cwd } = this.options;
+        return paths.forEach((path)=>{
+            isAbsolute(path) || this._closers.has(path) || (cwd && (path = join(cwd, path)), path = external_node_path_resolve(path)), this._closePath(path), this._addIgnoredPath(path), this._watched.has(path) && this._addIgnoredPath({
+                path,
+                recursive: !0
+            }), this._userIgnored = void 0;
+        }), this;
+    }
+    close() {
+        if (this._closePromise) return this._closePromise;
+        this.closed = !0, this.removeAllListeners();
+        let closers = [];
+        return this._closers.forEach((closerList)=>closerList.forEach((closer)=>{
+                let promise = closer();
+                promise instanceof Promise && closers.push(promise);
+            })), this._streams.forEach((stream)=>stream.destroy()), this._userIgnored = void 0, this._readyCount = 0, this._readyEmitted = !1, this._watched.forEach((dirent)=>dirent.dispose()), this._closers.clear(), this._watched.clear(), this._streams.clear(), this._symlinkPaths.clear(), this._throttled.clear(), this._closePromise = closers.length ? Promise.all(closers).then(()=>void 0) : Promise.resolve(), this._closePromise;
+    }
+    getWatched() {
+        let watchList = {};
+        return this._watched.forEach((entry, dir)=>{
+            watchList[(this.options.cwd ? external_node_path_relative(this.options.cwd, dir) : dir) || '.'] = entry.getChildren().sort();
+        }), watchList;
+    }
+    emitWithAll(event, args) {
+        this.emit(event, ...args), event !== EVENTS_ERROR && this.emit(EVENTS_ALL, event, ...args);
+    }
+    async _emit(event, path, stats) {
+        let pw;
+        if (this.closed) return;
+        let opts = this.options;
+        isWindows && (path = normalize(path)), opts.cwd && (path = external_node_path_relative(opts.cwd, path));
+        let args = [
+            path
+        ];
+        null != stats && args.push(stats);
+        let awf = opts.awaitWriteFinish;
+        if (awf && (pw = this._pendingWrites.get(path))) return pw.lastChange = new Date(), this;
+        if (opts.atomic) {
+            if (event === EVENTS_UNLINK) return this._pendingUnlinks.set(path, [
+                event,
+                ...args
+            ]), setTimeout(()=>{
+                this._pendingUnlinks.forEach((entry, path)=>{
+                    this.emit(...entry), this.emit(EVENTS_ALL, ...entry), this._pendingUnlinks.delete(path);
+                });
+            }, 'number' == typeof opts.atomic ? opts.atomic : 100), this;
+            event === EVENTS_ADD && this._pendingUnlinks.has(path) && (event = EVENTS_CHANGE, this._pendingUnlinks.delete(path));
+        }
+        if (awf && (event === EVENTS_ADD || event === EVENTS_CHANGE) && this._readyEmitted) {
+            let awfEmit = (err, stats)=>{
+                err ? (event = EVENTS_ERROR, args[0] = err, this.emitWithAll(event, args)) : stats && (args.length > 1 ? args[1] = stats : args.push(stats), this.emitWithAll(event, args));
+            };
+            return this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit), this;
+        }
+        if (event === EVENTS_CHANGE && !this._throttle(EVENTS_CHANGE, path, 50)) return this;
+        if (opts.alwaysStat && void 0 === stats && (event === EVENTS_ADD || event === EVENTS_ADD_DIR || event === EVENTS_CHANGE)) {
+            let stats, fullPath = opts.cwd ? join(opts.cwd, path) : path;
+            try {
+                stats = await promises_stat(fullPath);
+            } catch (err) {}
+            if (!stats || this.closed) return;
+            args.push(stats);
+        }
+        return this.emitWithAll(event, args), this;
+    }
+    _handleError(error) {
+        let code = error && error.code;
+        return error && 'ENOENT' !== code && 'ENOTDIR' !== code && (!this.options.ignorePermissionErrors || 'EPERM' !== code && 'EACCES' !== code) && this.emit(EVENTS_ERROR, error), error || this.closed;
+    }
+    _throttle(actionType, path, timeout) {
+        let timeoutObject;
+        this._throttled.has(actionType) || this._throttled.set(actionType, new Map());
+        let action = this._throttled.get(actionType);
+        if (!action) throw Error('invalid throttle');
+        let actionPath = action.get(path);
+        if (actionPath) return actionPath.count++, !1;
+        let clear = ()=>{
+            let item = action.get(path), count = item ? item.count : 0;
+            return action.delete(path), clearTimeout(timeoutObject), item && clearTimeout(item.timeoutObject), count;
+        }, thr = {
+            timeoutObject: timeoutObject = setTimeout(clear, timeout),
+            clear,
+            count: 0
+        };
+        return action.set(path, thr), thr;
+    }
+    _incrReadyCount() {
+        return this._readyCount++;
+    }
+    _awaitWriteFinish(path, threshold, event, awfEmit) {
+        let timeoutHandler, awf = this.options.awaitWriteFinish;
+        if ('object' != typeof awf) return;
+        let pollInterval = awf.pollInterval, fullPath = path;
+        this.options.cwd && !isAbsolute(path) && (fullPath = join(this.options.cwd, path));
+        let now = new Date(), writes = this._pendingWrites;
+        writes.has(path) || (writes.set(path, {
+            lastChange: now,
+            cancelWait: ()=>(writes.delete(path), clearTimeout(timeoutHandler), event)
+        }), timeoutHandler = setTimeout(function awaitWriteFinishFn(prevStat) {
+            external_node_fs_stat(fullPath, (err, curStat)=>{
+                if (err || !writes.has(path)) {
+                    err && 'ENOENT' !== err.code && awfEmit(err);
+                    return;
+                }
+                let now = Number(new Date());
+                prevStat && curStat.size !== prevStat.size && (writes.get(path).lastChange = now), now - writes.get(path).lastChange >= threshold ? (writes.delete(path), awfEmit(void 0, curStat)) : timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+            });
+        }, pollInterval));
+    }
+    _isIgnored(path, stats) {
+        if (this.options.atomic && DOT_RE.test(path)) return !0;
+        if (!this._userIgnored) {
+            let { cwd } = this.options, ignored = (this.options.ignored || []).map(normalizeIgnored(cwd)), list = [
+                ...[
+                    ...this._ignoredPaths
+                ].map(normalizeIgnored(cwd)),
+                ...ignored
+            ];
+            this._userIgnored = function(matchers, testString) {
+                if (null == matchers) throw TypeError('anymatch: specify first argument');
+                let patterns = arrify(matchers).map((matcher)=>'function' == typeof matcher ? matcher : 'string' == typeof matcher ? (string)=>matcher === string : matcher instanceof RegExp ? (string)=>matcher.test(string) : 'object' == typeof matcher && null !== matcher ? (string)=>{
+                        if (matcher.path === string) return !0;
+                        if (matcher.recursive) {
+                            let relative = external_node_path_relative(matcher.path, string);
+                            return !!relative && !relative.startsWith('..') && !isAbsolute(relative);
+                        }
+                        return !1;
+                    } : ()=>!1);
+                return null == testString ? (testString, stats)=>chokidar_matchPatterns(patterns, testString, stats) : chokidar_matchPatterns(patterns, testString);
+            }(list, void 0);
+        }
+        return this._userIgnored(path, stats);
+    }
+    _isntIgnored(path, stat) {
+        return !this._isIgnored(path, stat);
+    }
+    _getWatchHelpers(path) {
+        return new WatchHelper(path, this.options.followSymlinks, this);
+    }
+    _getWatchedDir(directory) {
+        let dir = external_node_path_resolve(directory);
+        return this._watched.has(dir) || this._watched.set(dir, new DirEntry(dir, this._boundRemove)), this._watched.get(dir);
+    }
+    _hasReadPermissions(stats) {
+        return !!this.options.ignorePermissionErrors || !!(256 & Number(stats.mode));
+    }
+    _remove(directory, item, isDirectory) {
+        let path = join(directory, item), fullPath = external_node_path_resolve(path);
+        if (isDirectory = null != isDirectory ? isDirectory : this._watched.has(path) || this._watched.has(fullPath), !this._throttle('remove', path, 100)) return;
+        isDirectory || 1 !== this._watched.size || this.add(directory, item, !0), this._getWatchedDir(path).getChildren().forEach((nested)=>this._remove(path, nested));
+        let parent = this._getWatchedDir(directory), wasTracked = parent.has(item);
+        parent.remove(item), this._symlinkPaths.has(fullPath) && this._symlinkPaths.delete(fullPath);
+        let relPath = path;
+        if (this.options.cwd && (relPath = external_node_path_relative(this.options.cwd, path)), this.options.awaitWriteFinish && this._pendingWrites.has(relPath) && this._pendingWrites.get(relPath).cancelWait() === EVENTS_ADD) return;
+        this._watched.delete(path), this._watched.delete(fullPath);
+        let eventName = isDirectory ? EVENTS_UNLINK_DIR : EVENTS_UNLINK;
+        wasTracked && !this._isIgnored(path) && this._emit(eventName, path), this._closePath(path);
+    }
+    _closePath(path) {
+        this._closeFile(path);
+        let dir = external_node_path_dirname(path);
+        this._getWatchedDir(dir).remove(external_node_path_basename(path));
+    }
+    _closeFile(path) {
+        let closers = this._closers.get(path);
+        closers && (closers.forEach((closer)=>closer()), this._closers.delete(path));
+    }
+    _addPathCloser(path, closer) {
+        if (!closer) return;
+        let list = this._closers.get(path);
+        list || (list = [], this._closers.set(path, list)), list.push(closer);
+    }
+    _readdirp(root, opts) {
+        if (this.closed) return;
+        let stream = function(root, options = {}) {
+            let type = options.entryType || options.type;
+            if ('both' === type && (type = EntryTypes_FILE_DIR_TYPE), type && (options.type = type), root) {
+                if ('string' != typeof root) throw TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+                else if (type && !ALL_TYPES.includes(type)) throw Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+            } else throw Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+            return options.root = root, new ReaddirpStream(options);
+        }(root, {
+            type: EVENTS_ALL,
+            alwaysStat: !0,
+            lstat: !0,
+            ...opts,
+            depth: 0
+        });
+        return this._streams.add(stream), stream.once('close', ()=>{
+            stream = void 0;
+        }), stream.once('end', ()=>{
+            stream && (this._streams.delete(stream), stream = void 0);
+        }), stream;
+    }
+}
+let chokidar_watch = function(paths, options = {}) {
+    let watcher = new FSWatcher(options);
+    return watcher.add(paths), watcher;
+}, 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 external_tinyglobby_glob(globPatterns, {
+    if (globPatterns.length) for (let file of (await dist_glob(globPatterns, {
         cwd: root,
         absolute: !0
     })))watchFiles.add(file);
-    return chokidar.watch(Array.from(watchFiles), {
+    return chokidar_watch(Array.from(watchFiles), {
         ignoreInitial: !0,
         ignorePermissionErrors: !0,
         ...options
@@ -3861,9 +7738,9 @@ async function setupUnpack(cliOptions, command) {
     };
 }
 function runCLI() {
-    let cli = cac('unpack');
+    let cli = ((name = "")=>new CAC(name))('unpack');
     cli.option('-c, --config <file>', 'Use specified config file').option('-r, --root <dir>', 'Specify root directory').option('-d, --debug', 'Show debug logs');
-    let devCommand = cli.command('', 'Start dev server').alias('dev'), buildCommand = cli.command('build', 'Build for production'), cleanCommand = cli.command('clean', 'Clean cache directory');
+    let devCommand = cli.command('', 'Start dev server').alias('dev'), buildCommand = cli.command('build', 'Build for production'), cleanCommand = cli.command('clean', 'Clean cache directory'), upCommand = cli.command('up', 'Upgrade unpack packages to the latest');
     buildCommand.option('-w, --watch', 'Rebuilds when modules have changed on disk').option('--analyze', 'Analyze the size of output files').action(withErrorHandling(async (options)=>{
         let { unpack } = await setupUnpack(options, 'build');
         await unpack.build({
@@ -3872,7 +7749,18 @@ function runCLI() {
     })), cleanCommand.action(withErrorHandling(async (options)=>{
         let { unpack } = await setupUnpack(options, 'build');
         unpack.clean();
-    }));
+    })), upCommand.action(()=>{
+        spawnSync('win32' === process.platform ? 'npx.cmd' : 'npx', [
+            '--yes',
+            'taze',
+            'minor',
+            '--include',
+            '/^@unpackjs\\//',
+            '-w'
+        ], {
+            stdio: 'inherit'
+        });
+    });
     let startServer = withErrorHandling(async (options)=>{
         let { unpack, config } = await setupUnpack(options, 'dev'), { port, url } = await unpack.dev();
         await setupCliShortcuts({
@@ -3900,8 +7788,8 @@ function runCLI() {
             logger_logger.clear(), logger_logger.info(`${node_path.basename(file)} changed, restarting server...`), await watcher.close(), await cleanUpBeforeRestart(), startServer(options);
         });
     });
-    devCommand.option('-o, --open [url]', 'Open browser on startup').option('--port <port>', 'Specify port').option('--host', 'Expose hostname').action(startServer), cli.help(), cli.version("4.7.2"), cli.parse();
+    devCommand.option('-o, --open [url]', 'Open browser on startup').option('--port <port>', 'Specify port').option('--host', 'Expose hostname').action(startServer), cli.help(), cli.version("4.7.4"), cli.parse();
 }
 let launch_editor = __webpack_require__("../../node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/index.js");
 var launch_editor_default_0 = __webpack_require__.n(launch_editor)(), src_CSS_MODULES_NAMED_EXPORT = !1;
-export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, CSS_MODULES_RESOURCE_QUERY_REGEX, CSS_REGEX, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LESS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SASS_REGEX, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, applyHtmlTagDescriptors, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, dist_default_0 as mergeConfig, emptyDir, ensureDir, esVersionToBrowserslist, external_tinyglobby_glob as glob, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getDevServerPort, getFilesContentHash, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, isBoolean, isDebug, isDev, isEmptyDir, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isString, isUndefined, isWin, launch_editor_default_0 as launchEditor, loadConfig, loadConfigFromFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, normalizePublicPath, openBrowser, pLimit, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, renderHtmlTagDescriptor, resolveConfigPath, rspack, runCLI, set, setCurrentUnpackConfig, setDevServer, setDevServerPort, setNodeEnv, setUnpackStartTime, src_CSS_MODULES_NAMED_EXPORT as CSS_MODULES_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd };
+export { ALL_INTERFACES_IPV4, CSS_MODULES_EXPORTS_CONVENTION, CSS_MODULES_LOCAL_IDENT_NAME, CSS_MODULES_RESOURCE_QUERY_REGEX, CSS_REGEX, DEV_DEFAULT_FILENAME, JSX_REGEX, JS_REGEX, LESS_REGEX, LOCALHOST, NODE_MODULES_REGEX, PROD_DEFAULT_FILENAME, SASS_REGEX, SCRIPT_REGEX, TEMPLATE_CONTENT, addRestartCleaner, applyHtmlTagDescriptors, cleanUpBeforeRestart, clearLine, colors, convertBasicAnsiColors, createChokidar, createUnpack, debounce, defineConfig, dist_default_0 as mergeConfig, dist_glob as glob, emptyDir, ensureDir, esVersionToBrowserslist, findExists, getAddressUrls, getCompiledPkgPath, getCurrentUnpackConfig, getDevServerPort, getFilesContentHash, getHtmlTemplateOrContent, getIpv4Interfaces, getNodeEnv, getOrSetDefault, getPathInJs, getPort, getTime, getUnpackStartTime, getUserDepPath, getUserDepVersion, globSync, isBoolean, isDebug, isDev, isEmptyDir, isFileSync, isFunction, isNodeVersionAtLeast, isObject, isPlainObject, isRegExp, isUndefined, launch_editor_default_0 as launchEditor, loadConfig, loadConfigFromFile, logUpdate, logger_LogColor as LogColor, logger_logger as logger, normalizePublicPath, openBrowser, pLimit, pathToExportIdentifier, prettyTime, printServerUrls, removeDir, renderHtmlTagDescriptor, resolveConfigPath, rspack, runCLI, setCurrentUnpackConfig, setDevServer, setDevServerPort, setNodeEnv, setUnpackStartTime, src_CSS_MODULES_NAMED_EXPORT as CSS_MODULES_NAMED_EXPORT, trackPerformance, utils_isDevServer as isDevServer, utils_isProd as isProd, utils_isString as isString, utils_isWin as isWin, utils_set as set };