@rspack/dev-server 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/0~http-proxy-middleware.js

@@ -0,0 +1,4447 @@
+/*! LICENSE: 0~http-proxy-middleware.js.LICENSE.txt */
+import { __webpack_require__ } from "./621.js";
+import "./621.js";
+import "./0~debug.js";
+__webpack_require__.add({
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
+        const compile = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js");
+        const expand = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js");
+        const parse = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js");
+        const braces = (input, options = {})=>{
+            let output = [];
+            if (Array.isArray(input)) for (const pattern of input){
+                const result = braces.create(pattern, options);
+                if (Array.isArray(result)) output.push(...result);
+                else output.push(result);
+            }
+            else output = [].concat(braces.create(input, options));
+            if (options && true === options.expand && true === options.nodupes) output = [
+                ...new Set(output)
+            ];
+            return output;
+        };
+        braces.parse = (input, options = {})=>parse(input, options);
+        braces.stringify = (input, options = {})=>{
+            if ('string' == typeof input) return stringify(braces.parse(input, options), options);
+            return stringify(input, options);
+        };
+        braces.compile = (input, options = {})=>{
+            if ('string' == typeof input) input = braces.parse(input, options);
+            return compile(input, options);
+        };
+        braces.expand = (input, options = {})=>{
+            if ('string' == typeof input) input = braces.parse(input, options);
+            let result = expand(input, options);
+            if (true === options.noempty) result = result.filter(Boolean);
+            if (true === options.nodupes) result = [
+                ...new Set(result)
+            ];
+            return result;
+        };
+        braces.create = (input, options = {})=>{
+            if ('' === input || input.length < 3) return [
+                input
+            ];
+            return true !== options.expand ? braces.compile(input, options) : braces.expand(input, options);
+        };
+        module.exports = braces;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/compile.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fill = __webpack_require__("./node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        const compile = (ast, options = {})=>{
+            const walk = (node, parent = {})=>{
+                const invalidBlock = utils.isInvalidBrace(parent);
+                const invalidNode = true === node.invalid && true === options.escapeInvalid;
+                const invalid = true === invalidBlock || true === invalidNode;
+                const prefix = true === options.escapeInvalid ? '\\' : '';
+                let output = '';
+                if (true === node.isOpen) return prefix + node.value;
+                if (true === node.isClose) {
+                    console.log('node.isClose', prefix, node.value);
+                    return prefix + node.value;
+                }
+                if ('open' === node.type) return invalid ? prefix + node.value : '(';
+                if ('close' === node.type) return invalid ? prefix + node.value : ')';
+                if ('comma' === node.type) return 'comma' === node.prev.type ? '' : invalid ? node.value : '|';
+                if (node.value) return node.value;
+                if (node.nodes && node.ranges > 0) {
+                    const args = utils.reduce(node.nodes);
+                    const range = fill(...args, {
+                        ...options,
+                        wrap: false,
+                        toRegex: true,
+                        strictZeros: true
+                    });
+                    if (0 !== range.length) return args.length > 1 && range.length > 1 ? `(${range})` : range;
+                }
+                if (node.nodes) for (const child of node.nodes)output += walk(child, node);
+                return output;
+            };
+            return walk(ast);
+        };
+        module.exports = compile;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js" (module) {
+        module.exports = {
+            MAX_LENGTH: 10000,
+            CHAR_0: '0',
+            CHAR_9: '9',
+            CHAR_UPPERCASE_A: 'A',
+            CHAR_LOWERCASE_A: 'a',
+            CHAR_UPPERCASE_Z: 'Z',
+            CHAR_LOWERCASE_Z: 'z',
+            CHAR_LEFT_PARENTHESES: '(',
+            CHAR_RIGHT_PARENTHESES: ')',
+            CHAR_ASTERISK: '*',
+            CHAR_AMPERSAND: '&',
+            CHAR_AT: '@',
+            CHAR_BACKSLASH: '\\',
+            CHAR_BACKTICK: '`',
+            CHAR_CARRIAGE_RETURN: '\r',
+            CHAR_CIRCUMFLEX_ACCENT: '^',
+            CHAR_COLON: ':',
+            CHAR_COMMA: ',',
+            CHAR_DOLLAR: '$',
+            CHAR_DOT: '.',
+            CHAR_DOUBLE_QUOTE: '"',
+            CHAR_EQUAL: '=',
+            CHAR_EXCLAMATION_MARK: '!',
+            CHAR_FORM_FEED: '\f',
+            CHAR_FORWARD_SLASH: '/',
+            CHAR_HASH: '#',
+            CHAR_HYPHEN_MINUS: '-',
+            CHAR_LEFT_ANGLE_BRACKET: '<',
+            CHAR_LEFT_CURLY_BRACE: '{',
+            CHAR_LEFT_SQUARE_BRACKET: '[',
+            CHAR_LINE_FEED: '\n',
+            CHAR_NO_BREAK_SPACE: '\u00A0',
+            CHAR_PERCENT: '%',
+            CHAR_PLUS: '+',
+            CHAR_QUESTION_MARK: '?',
+            CHAR_RIGHT_ANGLE_BRACKET: '>',
+            CHAR_RIGHT_CURLY_BRACE: '}',
+            CHAR_RIGHT_SQUARE_BRACKET: ']',
+            CHAR_SEMICOLON: ';',
+            CHAR_SINGLE_QUOTE: '\'',
+            CHAR_SPACE: ' ',
+            CHAR_TAB: '\t',
+            CHAR_UNDERSCORE: '_',
+            CHAR_VERTICAL_LINE: '|',
+            CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF'
+        };
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/expand.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const fill = __webpack_require__("./node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js");
+        const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        const append = (queue = '', stash = '', enclose = false)=>{
+            const result = [];
+            queue = [].concat(queue);
+            stash = [].concat(stash);
+            if (!stash.length) return queue;
+            if (!queue.length) return enclose ? utils.flatten(stash).map((ele)=>`{${ele}}`) : stash;
+            for (const item of queue)if (Array.isArray(item)) for (const value of item)result.push(append(value, stash, enclose));
+            else for (let ele of stash){
+                if (true === enclose && 'string' == typeof ele) ele = `{${ele}}`;
+                result.push(Array.isArray(ele) ? append(item, ele, enclose) : item + ele);
+            }
+            return utils.flatten(result);
+        };
+        const expand = (ast, options = {})=>{
+            const rangeLimit = void 0 === options.rangeLimit ? 1000 : options.rangeLimit;
+            const walk = (node, parent = {})=>{
+                node.queue = [];
+                let p = parent;
+                let q = parent.queue;
+                while('brace' !== p.type && 'root' !== p.type && p.parent){
+                    p = p.parent;
+                    q = p.queue;
+                }
+                if (node.invalid || node.dollar) return void q.push(append(q.pop(), stringify(node, options)));
+                if ('brace' === node.type && true !== node.invalid && 2 === node.nodes.length) return void q.push(append(q.pop(), [
+                    '{}'
+                ]));
+                if (node.nodes && node.ranges > 0) {
+                    const args = utils.reduce(node.nodes);
+                    if (utils.exceedsLimit(...args, options.step, rangeLimit)) throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
+                    let range = fill(...args, options);
+                    if (0 === range.length) range = stringify(node, options);
+                    q.push(append(q.pop(), range));
+                    node.nodes = [];
+                    return;
+                }
+                const enclose = utils.encloseBrace(node);
+                let queue = node.queue;
+                let block = node;
+                while('brace' !== block.type && 'root' !== block.type && block.parent){
+                    block = block.parent;
+                    queue = block.queue;
+                }
+                for(let i = 0; i < node.nodes.length; i++){
+                    const child = node.nodes[i];
+                    if ('comma' === child.type && 'brace' === node.type) {
+                        if (1 === i) queue.push('');
+                        queue.push('');
+                        continue;
+                    }
+                    if ('close' === child.type) {
+                        q.push(append(q.pop(), queue, enclose));
+                        continue;
+                    }
+                    if (child.value && 'open' !== child.type) {
+                        queue.push(append(queue.pop(), child.value));
+                        continue;
+                    }
+                    if (child.nodes) walk(child, node);
+                }
+                return queue;
+            };
+            return utils.flatten(walk(ast));
+        };
+        module.exports = expand;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const stringify = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js");
+        const { MAX_LENGTH, CHAR_BACKSLASH, CHAR_BACKTICK, CHAR_COMMA, CHAR_DOT, CHAR_LEFT_PARENTHESES, CHAR_RIGHT_PARENTHESES, CHAR_LEFT_CURLY_BRACE, CHAR_RIGHT_CURLY_BRACE, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_DOUBLE_QUOTE, CHAR_SINGLE_QUOTE, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_NOBREAK_SPACE } = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/constants.js");
+        const parse = (input, options = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            const opts = options || {};
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            if (input.length > max) throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
+            const ast = {
+                type: 'root',
+                input,
+                nodes: []
+            };
+            const stack = [
+                ast
+            ];
+            let block = ast;
+            let prev = ast;
+            let brackets = 0;
+            const length = input.length;
+            let index = 0;
+            let depth = 0;
+            let value;
+            const advance = ()=>input[index++];
+            const push = (node)=>{
+                if ('text' === node.type && 'dot' === prev.type) prev.type = 'text';
+                if (prev && 'text' === prev.type && 'text' === node.type) {
+                    prev.value += node.value;
+                    return;
+                }
+                block.nodes.push(node);
+                node.parent = block;
+                node.prev = prev;
+                prev = node;
+                return node;
+            };
+            push({
+                type: 'bos'
+            });
+            while(index < length){
+                block = stack[stack.length - 1];
+                value = advance();
+                if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) continue;
+                if (value === CHAR_BACKSLASH) {
+                    push({
+                        type: 'text',
+                        value: (options.keepEscaping ? value : '') + advance()
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+                    push({
+                        type: 'text',
+                        value: '\\' + value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_SQUARE_BRACKET) {
+                    brackets++;
+                    let next;
+                    while(index < length && (next = advance())){
+                        value += next;
+                        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+                            brackets++;
+                            continue;
+                        }
+                        if (next === CHAR_BACKSLASH) {
+                            value += advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            brackets--;
+                            if (0 === brackets) break;
+                        }
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_PARENTHESES) {
+                    block = push({
+                        type: 'paren',
+                        nodes: []
+                    });
+                    stack.push(block);
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_PARENTHESES) {
+                    if ('paren' !== block.type) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    block = stack.pop();
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
+                    const open = value;
+                    let next;
+                    if (true !== options.keepQuotes) value = '';
+                    while(index < length && (next = advance())){
+                        if (next === CHAR_BACKSLASH) {
+                            value += next + advance();
+                            continue;
+                        }
+                        if (next === open) {
+                            if (true === options.keepQuotes) value += next;
+                            break;
+                        }
+                        value += next;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_LEFT_CURLY_BRACE) {
+                    depth++;
+                    const dollar = prev.value && '$' === prev.value.slice(-1) || true === block.dollar;
+                    const brace = {
+                        type: 'brace',
+                        open: true,
+                        close: false,
+                        dollar,
+                        depth,
+                        commas: 0,
+                        ranges: 0,
+                        nodes: []
+                    };
+                    block = push(brace);
+                    stack.push(block);
+                    push({
+                        type: 'open',
+                        value
+                    });
+                    continue;
+                }
+                if (value === CHAR_RIGHT_CURLY_BRACE) {
+                    if ('brace' !== block.type) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    const type = 'close';
+                    block = stack.pop();
+                    block.close = true;
+                    push({
+                        type,
+                        value
+                    });
+                    depth--;
+                    block = stack[stack.length - 1];
+                    continue;
+                }
+                if (value === CHAR_COMMA && depth > 0) {
+                    if (block.ranges > 0) {
+                        block.ranges = 0;
+                        const open = block.nodes.shift();
+                        block.nodes = [
+                            open,
+                            {
+                                type: 'text',
+                                value: stringify(block)
+                            }
+                        ];
+                    }
+                    push({
+                        type: 'comma',
+                        value
+                    });
+                    block.commas++;
+                    continue;
+                }
+                if (value === CHAR_DOT && depth > 0 && 0 === block.commas) {
+                    const siblings = block.nodes;
+                    if (0 === depth || 0 === siblings.length) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    if ('dot' === prev.type) {
+                        block.range = [];
+                        prev.value += value;
+                        prev.type = 'range';
+                        if (3 !== block.nodes.length && 5 !== block.nodes.length) {
+                            block.invalid = true;
+                            block.ranges = 0;
+                            prev.type = 'text';
+                            continue;
+                        }
+                        block.ranges++;
+                        block.args = [];
+                        continue;
+                    }
+                    if ('range' === prev.type) {
+                        siblings.pop();
+                        const before = siblings[siblings.length - 1];
+                        before.value += prev.value + value;
+                        prev = before;
+                        block.ranges--;
+                        continue;
+                    }
+                    push({
+                        type: 'dot',
+                        value
+                    });
+                    continue;
+                }
+                push({
+                    type: 'text',
+                    value
+                });
+            }
+            do {
+                block = stack.pop();
+                if ('root' !== block.type) {
+                    block.nodes.forEach((node)=>{
+                        if (!node.nodes) {
+                            if ('open' === node.type) node.isOpen = true;
+                            if ('close' === node.type) node.isClose = true;
+                            if (!node.nodes) node.type = 'text';
+                            node.invalid = true;
+                        }
+                    });
+                    const parent = stack[stack.length - 1];
+                    const index = parent.nodes.indexOf(block);
+                    parent.nodes.splice(index, 1, ...block.nodes);
+                }
+            }while (stack.length > 0);
+            push({
+                type: 'eos'
+            });
+            return ast;
+        };
+        module.exports = parse;
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/stringify.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const utils = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js");
+        module.exports = (ast, options = {})=>{
+            const stringify = (node, parent = {})=>{
+                const invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+                const invalidNode = true === node.invalid && true === options.escapeInvalid;
+                let output = '';
+                if (node.value) {
+                    if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) return '\\' + node.value;
+                    return node.value;
+                }
+                if (node.value) return node.value;
+                if (node.nodes) for (const child of node.nodes)output += stringify(child);
+                return output;
+            };
+            return stringify(ast);
+        };
+    },
+    "./node_modules/.pnpm/braces@3.0.3/node_modules/braces/lib/utils.js" (__unused_rspack_module, exports) {
+        exports.isInteger = (num)=>{
+            if ('number' == typeof num) return Number.isInteger(num);
+            if ('string' == typeof num && '' !== num.trim()) return Number.isInteger(Number(num));
+            return false;
+        };
+        exports.find = (node, type)=>node.nodes.find((node)=>node.type === type);
+        exports.exceedsLimit = (min, max, step = 1, limit)=>{
+            if (false === limit) return false;
+            if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
+            return (Number(max) - Number(min)) / Number(step) >= limit;
+        };
+        exports.escapeNode = (block, n = 0, type)=>{
+            const node = block.nodes[n];
+            if (!node) return;
+            if (type && node.type === type || 'open' === node.type || 'close' === node.type) {
+                if (true !== node.escaped) {
+                    node.value = '\\' + node.value;
+                    node.escaped = true;
+                }
+            }
+        };
+        exports.encloseBrace = (node)=>{
+            if ('brace' !== node.type) return false;
+            if (node.commas >> 0 + node.ranges === 0) {
+                node.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        exports.isInvalidBrace = (block)=>{
+            if ('brace' !== block.type) return false;
+            if (true === block.invalid || block.dollar) return true;
+            if (block.commas >> 0 + block.ranges === 0) {
+                block.invalid = true;
+                return true;
+            }
+            if (true !== block.open || true !== block.close) {
+                block.invalid = true;
+                return true;
+            }
+            return false;
+        };
+        exports.isOpenOrClose = (node)=>{
+            if ('open' === node.type || 'close' === node.type) return true;
+            return true === node.open || true === node.close;
+        };
+        exports.reduce = (nodes)=>nodes.reduce((acc, node)=>{
+                if ('text' === node.type) acc.push(node.value);
+                if ('range' === node.type) node.type = 'text';
+                return acc;
+            }, []);
+        exports.flatten = (...args)=>{
+            const result = [];
+            const flat = (arr)=>{
+                for(let i = 0; i < arr.length; i++){
+                    const ele = arr[i];
+                    if (Array.isArray(ele)) {
+                        flat(ele);
+                        continue;
+                    }
+                    if (void 0 !== ele) result.push(ele);
+                }
+                return result;
+            };
+            flat(args);
+            return result;
+        };
+    },
+    "./node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js" (module) {
+        var has = Object.prototype.hasOwnProperty, prefix = '~';
+        function Events() {}
+        if (Object.create) {
+            Events.prototype = Object.create(null);
+            if (!new Events().__proto__) prefix = false;
+        }
+        function EE(fn, context, once) {
+            this.fn = fn;
+            this.context = context;
+            this.once = once || false;
+        }
+        function addListener(emitter, event, fn, context, once) {
+            if ('function' != typeof fn) throw new TypeError('The listener must be a function');
+            var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+            if (emitter._events[evt]) if (emitter._events[evt].fn) emitter._events[evt] = [
+                emitter._events[evt],
+                listener
+            ];
+            else emitter._events[evt].push(listener);
+            else emitter._events[evt] = listener, emitter._eventsCount++;
+            return emitter;
+        }
+        function clearEvent(emitter, evt) {
+            if (0 === --emitter._eventsCount) emitter._events = new Events();
+            else delete emitter._events[evt];
+        }
+        function EventEmitter() {
+            this._events = new Events();
+            this._eventsCount = 0;
+        }
+        EventEmitter.prototype.eventNames = function() {
+            var names = [], events, name;
+            if (0 === this._eventsCount) return names;
+            for(name in events = this._events)if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+            if (Object.getOwnPropertySymbols) return names.concat(Object.getOwnPropertySymbols(events));
+            return names;
+        };
+        EventEmitter.prototype.listeners = function(event) {
+            var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+            if (!handlers) return [];
+            if (handlers.fn) return [
+                handlers.fn
+            ];
+            for(var i = 0, l = handlers.length, ee = new Array(l); i < l; i++)ee[i] = handlers[i].fn;
+            return ee;
+        };
+        EventEmitter.prototype.listenerCount = function(event) {
+            var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+            if (!listeners) return 0;
+            if (listeners.fn) return 1;
+            return listeners.length;
+        };
+        EventEmitter.prototype.emit = function(event, a1, a2, a3, a4, a5) {
+            var evt = prefix ? prefix + event : event;
+            if (!this._events[evt]) return false;
+            var listeners = this._events[evt], len = arguments.length, args, i;
+            if (listeners.fn) {
+                if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+                switch(len){
+                    case 1:
+                        return listeners.fn.call(listeners.context), true;
+                    case 2:
+                        return listeners.fn.call(listeners.context, a1), true;
+                    case 3:
+                        return listeners.fn.call(listeners.context, a1, a2), true;
+                    case 4:
+                        return listeners.fn.call(listeners.context, a1, a2, a3), true;
+                    case 5:
+                        return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+                    case 6:
+                        return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+                }
+                for(i = 1, args = new Array(len - 1); i < len; i++)args[i - 1] = arguments[i];
+                listeners.fn.apply(listeners.context, args);
+            } else {
+                var length = listeners.length, j;
+                for(i = 0; i < length; i++){
+                    if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+                    switch(len){
+                        case 1:
+                            listeners[i].fn.call(listeners[i].context);
+                            break;
+                        case 2:
+                            listeners[i].fn.call(listeners[i].context, a1);
+                            break;
+                        case 3:
+                            listeners[i].fn.call(listeners[i].context, a1, a2);
+                            break;
+                        case 4:
+                            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+                            break;
+                        default:
+                            if (!args) for(j = 1, args = new Array(len - 1); j < len; j++)args[j - 1] = arguments[j];
+                            listeners[i].fn.apply(listeners[i].context, args);
+                    }
+                }
+            }
+            return true;
+        };
+        EventEmitter.prototype.on = function(event, fn, context) {
+            return addListener(this, event, fn, context, false);
+        };
+        EventEmitter.prototype.once = function(event, fn, context) {
+            return addListener(this, event, fn, context, true);
+        };
+        EventEmitter.prototype.removeListener = function(event, fn, context, once) {
+            var evt = prefix ? prefix + event : event;
+            if (!this._events[evt]) return this;
+            if (!fn) {
+                clearEvent(this, evt);
+                return this;
+            }
+            var listeners = this._events[evt];
+            if (listeners.fn) {
+                if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) clearEvent(this, evt);
+            } else {
+                for(var i = 0, events = [], length = listeners.length; i < length; i++)if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) events.push(listeners[i]);
+                if (events.length) this._events[evt] = 1 === events.length ? events[0] : events;
+                else clearEvent(this, evt);
+            }
+            return this;
+        };
+        EventEmitter.prototype.removeAllListeners = function(event) {
+            var evt;
+            if (event) {
+                evt = prefix ? prefix + event : event;
+                if (this._events[evt]) clearEvent(this, evt);
+            } else {
+                this._events = new Events();
+                this._eventsCount = 0;
+            }
+            return this;
+        };
+        EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+        EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+        EventEmitter.prefixed = prefix;
+        EventEmitter.EventEmitter = EventEmitter;
+        module.exports = EventEmitter;
+    },
+    "./node_modules/.pnpm/fill-range@7.1.1/node_modules/fill-range/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ const util = __webpack_require__("util");
+        const toRegexRange = __webpack_require__("./node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js");
+        const isObject = (val)=>null !== val && 'object' == typeof val && !Array.isArray(val);
+        const transform = (toNumber)=>(value)=>true === toNumber ? Number(value) : String(value);
+        const isValidValue = (value)=>'number' == typeof value || 'string' == typeof value && '' !== value;
+        const isNumber = (num)=>Number.isInteger(+num);
+        const zeros = (input)=>{
+            let value = `${input}`;
+            let index = -1;
+            if ('-' === value[0]) value = value.slice(1);
+            if ('0' === value) return false;
+            while('0' === value[++index]);
+            return index > 0;
+        };
+        const stringify = (start, end, options)=>{
+            if ('string' == typeof start || 'string' == typeof end) return true;
+            return true === options.stringify;
+        };
+        const pad = (input, maxLength, toNumber)=>{
+            if (maxLength > 0) {
+                let dash = '-' === input[0] ? '-' : '';
+                if (dash) input = input.slice(1);
+                input = dash + input.padStart(dash ? maxLength - 1 : maxLength, '0');
+            }
+            if (false === toNumber) return String(input);
+            return input;
+        };
+        const toMaxLen = (input, maxLength)=>{
+            let negative = '-' === input[0] ? '-' : '';
+            if (negative) {
+                input = input.slice(1);
+                maxLength--;
+            }
+            while(input.length < maxLength)input = '0' + input;
+            return negative ? '-' + input : input;
+        };
+        const toSequence = (parts, options, maxLen)=>{
+            parts.negatives.sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+            parts.positives.sort((a, b)=>a < b ? -1 : a > b ? 1 : 0);
+            let prefix = options.capture ? '' : '?:';
+            let positives = '';
+            let negatives = '';
+            let result;
+            if (parts.positives.length) positives = parts.positives.map((v)=>toMaxLen(String(v), maxLen)).join('|');
+            if (parts.negatives.length) negatives = `-(${prefix}${parts.negatives.map((v)=>toMaxLen(String(v), maxLen)).join('|')})`;
+            result = positives && negatives ? `${positives}|${negatives}` : positives || negatives;
+            if (options.wrap) return `(${prefix}${result})`;
+            return result;
+        };
+        const toRange = (a, b, isNumbers, options)=>{
+            if (isNumbers) return toRegexRange(a, b, {
+                wrap: false,
+                ...options
+            });
+            let start = String.fromCharCode(a);
+            if (a === b) return start;
+            let stop = String.fromCharCode(b);
+            return `[${start}-${stop}]`;
+        };
+        const toRegex = (start, end, options)=>{
+            if (Array.isArray(start)) {
+                let wrap = true === options.wrap;
+                let prefix = options.capture ? '' : '?:';
+                return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
+            }
+            return toRegexRange(start, end, options);
+        };
+        const rangeError = (...args)=>new RangeError('Invalid range arguments: ' + util.inspect(...args));
+        const invalidRange = (start, end, options)=>{
+            if (true === options.strictRanges) throw rangeError([
+                start,
+                end
+            ]);
+            return [];
+        };
+        const invalidStep = (step, options)=>{
+            if (true === options.strictRanges) throw new TypeError(`Expected step "${step}" to be a number`);
+            return [];
+        };
+        const fillNumbers = (start, end, step = 1, options = {})=>{
+            let a = Number(start);
+            let b = Number(end);
+            if (!Number.isInteger(a) || !Number.isInteger(b)) {
+                if (true === options.strictRanges) throw rangeError([
+                    start,
+                    end
+                ]);
+                return [];
+            }
+            if (0 === a) a = 0;
+            if (0 === b) b = 0;
+            let descending = a > b;
+            let startString = String(start);
+            let endString = String(end);
+            let stepString = String(step);
+            step = Math.max(Math.abs(step), 1);
+            let padded = zeros(startString) || zeros(endString) || zeros(stepString);
+            let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
+            let toNumber = false === padded && false === stringify(start, end, options);
+            let format = options.transform || transform(toNumber);
+            if (options.toRegex && 1 === step) return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
+            let parts = {
+                negatives: [],
+                positives: []
+            };
+            let push = (num)=>parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
+            let range = [];
+            let index = 0;
+            while(descending ? a >= b : a <= b){
+                if (true === options.toRegex && step > 1) push(a);
+                else range.push(pad(format(a, index), maxLen, toNumber));
+                a = descending ? a - step : a + step;
+                index++;
+            }
+            if (true === options.toRegex) return step > 1 ? toSequence(parts, options, maxLen) : toRegex(range, null, {
+                wrap: false,
+                ...options
+            });
+            return range;
+        };
+        const fillLetters = (start, end, step = 1, options = {})=>{
+            if (!isNumber(start) && start.length > 1 || !isNumber(end) && end.length > 1) return invalidRange(start, end, options);
+            let format = options.transform || ((val)=>String.fromCharCode(val));
+            let a = `${start}`.charCodeAt(0);
+            let b = `${end}`.charCodeAt(0);
+            let descending = a > b;
+            let min = Math.min(a, b);
+            let max = Math.max(a, b);
+            if (options.toRegex && 1 === step) return toRange(min, max, false, options);
+            let range = [];
+            let index = 0;
+            while(descending ? a >= b : a <= b){
+                range.push(format(a, index));
+                a = descending ? a - step : a + step;
+                index++;
+            }
+            if (true === options.toRegex) return toRegex(range, null, {
+                wrap: false,
+                options
+            });
+            return range;
+        };
+        const fill = (start, end, step, options = {})=>{
+            if (null == end && isValidValue(start)) return [
+                start
+            ];
+            if (!isValidValue(start) || !isValidValue(end)) return invalidRange(start, end, options);
+            if ('function' == typeof step) return fill(start, end, 1, {
+                transform: step
+            });
+            if (isObject(step)) return fill(start, end, 0, step);
+            let opts = {
+                ...options
+            };
+            if (true === opts.capture) opts.wrap = true;
+            step = step || opts.step || 1;
+            if (!isNumber(step)) {
+                if (null != step && !isObject(step)) return invalidStep(step, opts);
+                return fill(start, end, 1, step);
+            }
+            if (isNumber(start) && isNumber(end)) return fillNumbers(start, end, step, opts);
+            return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
+        };
+        module.exports = fill;
+    },
+    "./node_modules/.pnpm/follow-redirects@1.15.9_debug@4.4.3/node_modules/follow-redirects/debug.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var debug;
+        module.exports = function() {
+            if (!debug) {
+                try {
+                    debug = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js")("follow-redirects");
+                } catch (error) {}
+                if ("function" != typeof debug) debug = function() {};
+            }
+            debug.apply(null, arguments);
+        };
+    },
+    "./node_modules/.pnpm/follow-redirects@1.15.9_debug@4.4.3/node_modules/follow-redirects/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var url = __webpack_require__("url");
+        var URL = url.URL;
+        var http = __webpack_require__("http");
+        var https = __webpack_require__("https");
+        var Writable = __webpack_require__("stream").Writable;
+        var assert = __webpack_require__("assert");
+        var debug = __webpack_require__("./node_modules/.pnpm/follow-redirects@1.15.9_debug@4.4.3/node_modules/follow-redirects/debug.js");
+        (function() {
+            var looksLikeNode = "u" > typeof process;
+            var looksLikeBrowser = "u" > typeof window && "u" > typeof document;
+            var looksLikeV8 = isFunction(Error.captureStackTrace);
+            if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) console.warn("The follow-redirects package should be excluded from browser builds.");
+        })();
+        var useNativeURL = false;
+        try {
+            assert(new URL(""));
+        } catch (error) {
+            useNativeURL = "ERR_INVALID_URL" === error.code;
+        }
+        var preservedUrlFields = [
+            "auth",
+            "host",
+            "hostname",
+            "href",
+            "path",
+            "pathname",
+            "port",
+            "protocol",
+            "query",
+            "search",
+            "hash"
+        ];
+        var events = [
+            "abort",
+            "aborted",
+            "connect",
+            "error",
+            "socket",
+            "timeout"
+        ];
+        var eventHandlers = Object.create(null);
+        events.forEach(function(event) {
+            eventHandlers[event] = function(arg1, arg2, arg3) {
+                this._redirectable.emit(event, arg1, arg2, arg3);
+            };
+        });
+        var InvalidUrlError = createErrorType("ERR_INVALID_URL", "Invalid URL", TypeError);
+        var RedirectionError = createErrorType("ERR_FR_REDIRECTION_FAILURE", "Redirected request failed");
+        var TooManyRedirectsError = createErrorType("ERR_FR_TOO_MANY_REDIRECTS", "Maximum number of redirects exceeded", RedirectionError);
+        var MaxBodyLengthExceededError = createErrorType("ERR_FR_MAX_BODY_LENGTH_EXCEEDED", "Request body larger than maxBodyLength limit");
+        var WriteAfterEndError = createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+        var destroy = Writable.prototype.destroy || noop;
+        function RedirectableRequest(options, responseCallback) {
+            Writable.call(this);
+            this._sanitizeOptions(options);
+            this._options = options;
+            this._ended = false;
+            this._ending = false;
+            this._redirectCount = 0;
+            this._redirects = [];
+            this._requestBodyLength = 0;
+            this._requestBodyBuffers = [];
+            if (responseCallback) this.on("response", responseCallback);
+            var self = this;
+            this._onNativeResponse = function(response) {
+                try {
+                    self._processResponse(response);
+                } catch (cause) {
+                    self.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({
+                        cause: cause
+                    }));
+                }
+            };
+            this._performRequest();
+        }
+        RedirectableRequest.prototype = Object.create(Writable.prototype);
+        RedirectableRequest.prototype.abort = function() {
+            destroyRequest(this._currentRequest);
+            this._currentRequest.abort();
+            this.emit("abort");
+        };
+        RedirectableRequest.prototype.destroy = function(error) {
+            destroyRequest(this._currentRequest, error);
+            destroy.call(this, error);
+            return this;
+        };
+        RedirectableRequest.prototype.write = function(data, encoding, callback) {
+            if (this._ending) throw new WriteAfterEndError();
+            if (!isString(data) && !isBuffer(data)) throw new TypeError("data should be a string, Buffer or Uint8Array");
+            if (isFunction(encoding)) {
+                callback = encoding;
+                encoding = null;
+            }
+            if (0 === data.length) {
+                if (callback) callback();
+                return;
+            }
+            if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+                this._requestBodyLength += data.length;
+                this._requestBodyBuffers.push({
+                    data: data,
+                    encoding: encoding
+                });
+                this._currentRequest.write(data, encoding, callback);
+            } else {
+                this.emit("error", new MaxBodyLengthExceededError());
+                this.abort();
+            }
+        };
+        RedirectableRequest.prototype.end = function(data, encoding, callback) {
+            if (isFunction(data)) {
+                callback = data;
+                data = encoding = null;
+            } else if (isFunction(encoding)) {
+                callback = encoding;
+                encoding = null;
+            }
+            if (data) {
+                var self = this;
+                var currentRequest = this._currentRequest;
+                this.write(data, encoding, function() {
+                    self._ended = true;
+                    currentRequest.end(null, null, callback);
+                });
+                this._ending = true;
+            } else {
+                this._ended = this._ending = true;
+                this._currentRequest.end(null, null, callback);
+            }
+        };
+        RedirectableRequest.prototype.setHeader = function(name, value) {
+            this._options.headers[name] = value;
+            this._currentRequest.setHeader(name, value);
+        };
+        RedirectableRequest.prototype.removeHeader = function(name) {
+            delete this._options.headers[name];
+            this._currentRequest.removeHeader(name);
+        };
+        RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
+            var self = this;
+            function destroyOnTimeout(socket) {
+                socket.setTimeout(msecs);
+                socket.removeListener("timeout", socket.destroy);
+                socket.addListener("timeout", socket.destroy);
+            }
+            function startTimer(socket) {
+                if (self._timeout) clearTimeout(self._timeout);
+                self._timeout = setTimeout(function() {
+                    self.emit("timeout");
+                    clearTimer();
+                }, msecs);
+                destroyOnTimeout(socket);
+            }
+            function clearTimer() {
+                if (self._timeout) {
+                    clearTimeout(self._timeout);
+                    self._timeout = null;
+                }
+                self.removeListener("abort", clearTimer);
+                self.removeListener("error", clearTimer);
+                self.removeListener("response", clearTimer);
+                self.removeListener("close", clearTimer);
+                if (callback) self.removeListener("timeout", callback);
+                if (!self.socket) self._currentRequest.removeListener("socket", startTimer);
+            }
+            if (callback) this.on("timeout", callback);
+            if (this.socket) startTimer(this.socket);
+            else this._currentRequest.once("socket", startTimer);
+            this.on("socket", destroyOnTimeout);
+            this.on("abort", clearTimer);
+            this.on("error", clearTimer);
+            this.on("response", clearTimer);
+            this.on("close", clearTimer);
+            return this;
+        };
+        [
+            "flushHeaders",
+            "getHeader",
+            "setNoDelay",
+            "setSocketKeepAlive"
+        ].forEach(function(method) {
+            RedirectableRequest.prototype[method] = function(a, b) {
+                return this._currentRequest[method](a, b);
+            };
+        });
+        [
+            "aborted",
+            "connection",
+            "socket"
+        ].forEach(function(property) {
+            Object.defineProperty(RedirectableRequest.prototype, property, {
+                get: function() {
+                    return this._currentRequest[property];
+                }
+            });
+        });
+        RedirectableRequest.prototype._sanitizeOptions = function(options) {
+            if (!options.headers) options.headers = {};
+            if (options.host) {
+                if (!options.hostname) options.hostname = options.host;
+                delete options.host;
+            }
+            if (!options.pathname && options.path) {
+                var searchPos = options.path.indexOf("?");
+                if (searchPos < 0) options.pathname = options.path;
+                else {
+                    options.pathname = options.path.substring(0, searchPos);
+                    options.search = options.path.substring(searchPos);
+                }
+            }
+        };
+        RedirectableRequest.prototype._performRequest = function() {
+            var protocol = this._options.protocol;
+            var nativeProtocol = this._options.nativeProtocols[protocol];
+            if (!nativeProtocol) throw new TypeError("Unsupported protocol " + protocol);
+            if (this._options.agents) {
+                var scheme = protocol.slice(0, -1);
+                this._options.agent = this._options.agents[scheme];
+            }
+            var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+            request._redirectable = this;
+            for (var event of events)request.on(event, eventHandlers[event]);
+            this._currentUrl = /^\//.test(this._options.path) ? url.format(this._options) : this._options.path;
+            if (this._isRedirect) {
+                var i = 0;
+                var self = this;
+                var buffers = this._requestBodyBuffers;
+                (function writeNext(error) {
+                    if (request === self._currentRequest) {
+                        if (error) self.emit("error", error);
+                        else if (i < buffers.length) {
+                            var buffer = buffers[i++];
+                            if (!request.finished) request.write(buffer.data, buffer.encoding, writeNext);
+                        } else if (self._ended) request.end();
+                    }
+                })();
+            }
+        };
+        RedirectableRequest.prototype._processResponse = function(response) {
+            var statusCode = response.statusCode;
+            if (this._options.trackRedirects) this._redirects.push({
+                url: this._currentUrl,
+                headers: response.headers,
+                statusCode: statusCode
+            });
+            var location = response.headers.location;
+            if (!location || false === this._options.followRedirects || statusCode < 300 || statusCode >= 400) {
+                response.responseUrl = this._currentUrl;
+                response.redirects = this._redirects;
+                this.emit("response", response);
+                this._requestBodyBuffers = [];
+                return;
+            }
+            destroyRequest(this._currentRequest);
+            response.destroy();
+            if (++this._redirectCount > this._options.maxRedirects) throw new TooManyRedirectsError();
+            var requestHeaders;
+            var beforeRedirect = this._options.beforeRedirect;
+            if (beforeRedirect) requestHeaders = Object.assign({
+                Host: response.req.getHeader("host")
+            }, this._options.headers);
+            var method = this._options.method;
+            if ((301 === statusCode || 302 === statusCode) && "POST" === this._options.method || 303 === statusCode && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+                this._options.method = "GET";
+                this._requestBodyBuffers = [];
+                removeMatchingHeaders(/^content-/i, this._options.headers);
+            }
+            var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+            var currentUrlParts = parseUrl(this._currentUrl);
+            var currentHost = currentHostHeader || currentUrlParts.host;
+            var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url.format(Object.assign(currentUrlParts, {
+                host: currentHost
+            }));
+            var redirectUrl = resolveUrl(location, currentUrl);
+            debug("redirecting to", redirectUrl.href);
+            this._isRedirect = true;
+            spreadUrlObject(redirectUrl, this._options);
+            if (redirectUrl.protocol !== currentUrlParts.protocol && "https:" !== redirectUrl.protocol || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+            if (isFunction(beforeRedirect)) {
+                var responseDetails = {
+                    headers: response.headers,
+                    statusCode: statusCode
+                };
+                var requestDetails = {
+                    url: currentUrl,
+                    method: method,
+                    headers: requestHeaders
+                };
+                beforeRedirect(this._options, responseDetails, requestDetails);
+                this._sanitizeOptions(this._options);
+            }
+            this._performRequest();
+        };
+        function wrap(protocols) {
+            var exports = {
+                maxRedirects: 21,
+                maxBodyLength: 10485760
+            };
+            var nativeProtocols = {};
+            Object.keys(protocols).forEach(function(scheme) {
+                var protocol = scheme + ":";
+                var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+                var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol);
+                function request(input, options, callback) {
+                    if (isURL(input)) input = spreadUrlObject(input);
+                    else if (isString(input)) input = spreadUrlObject(parseUrl(input));
+                    else {
+                        callback = options;
+                        options = validateUrl(input);
+                        input = {
+                            protocol: protocol
+                        };
+                    }
+                    if (isFunction(options)) {
+                        callback = options;
+                        options = null;
+                    }
+                    options = Object.assign({
+                        maxRedirects: exports.maxRedirects,
+                        maxBodyLength: exports.maxBodyLength
+                    }, input, options);
+                    options.nativeProtocols = nativeProtocols;
+                    if (!isString(options.host) && !isString(options.hostname)) options.hostname = "::1";
+                    assert.equal(options.protocol, protocol, "protocol mismatch");
+                    debug("options", options);
+                    return new RedirectableRequest(options, callback);
+                }
+                function get(input, options, callback) {
+                    var wrappedRequest = wrappedProtocol.request(input, options, callback);
+                    wrappedRequest.end();
+                    return wrappedRequest;
+                }
+                Object.defineProperties(wrappedProtocol, {
+                    request: {
+                        value: request,
+                        configurable: true,
+                        enumerable: true,
+                        writable: true
+                    },
+                    get: {
+                        value: get,
+                        configurable: true,
+                        enumerable: true,
+                        writable: true
+                    }
+                });
+            });
+            return exports;
+        }
+        function noop() {}
+        function parseUrl(input) {
+            var parsed;
+            if (useNativeURL) parsed = new URL(input);
+            else {
+                parsed = validateUrl(url.parse(input));
+                if (!isString(parsed.protocol)) throw new InvalidUrlError({
+                    input
+                });
+            }
+            return parsed;
+        }
+        function resolveUrl(relative, base) {
+            return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative));
+        }
+        function validateUrl(input) {
+            if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) throw new InvalidUrlError({
+                input: input.href || input
+            });
+            if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) throw new InvalidUrlError({
+                input: input.href || input
+            });
+            return input;
+        }
+        function spreadUrlObject(urlObject, target) {
+            var spread = target || {};
+            for (var key of preservedUrlFields)spread[key] = urlObject[key];
+            if (spread.hostname.startsWith("[")) spread.hostname = spread.hostname.slice(1, -1);
+            if ("" !== spread.port) spread.port = Number(spread.port);
+            spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+            return spread;
+        }
+        function removeMatchingHeaders(regex, headers) {
+            var lastValue;
+            for(var header in headers)if (regex.test(header)) {
+                lastValue = headers[header];
+                delete headers[header];
+            }
+            return null == lastValue ? void 0 : String(lastValue).trim();
+        }
+        function createErrorType(code, message, baseClass) {
+            function CustomError(properties) {
+                if (isFunction(Error.captureStackTrace)) Error.captureStackTrace(this, this.constructor);
+                Object.assign(this, properties || {});
+                this.code = code;
+                this.message = this.cause ? message + ": " + this.cause.message : message;
+            }
+            CustomError.prototype = new (baseClass || Error)();
+            Object.defineProperties(CustomError.prototype, {
+                constructor: {
+                    value: CustomError,
+                    enumerable: false
+                },
+                name: {
+                    value: "Error [" + code + "]",
+                    enumerable: false
+                }
+            });
+            return CustomError;
+        }
+        function destroyRequest(request, error) {
+            for (var event of events)request.removeListener(event, eventHandlers[event]);
+            request.on("error", noop);
+            request.destroy(error);
+        }
+        function isSubdomain(subdomain, domain) {
+            assert(isString(subdomain) && isString(domain));
+            var dot = subdomain.length - domain.length - 1;
+            return dot > 0 && "." === subdomain[dot] && subdomain.endsWith(domain);
+        }
+        function isString(value) {
+            return "string" == typeof value || value instanceof String;
+        }
+        function isFunction(value) {
+            return "function" == typeof value;
+        }
+        function isBuffer(value) {
+            return "object" == typeof value && "length" in value;
+        }
+        function isURL(value) {
+            return URL && value instanceof URL;
+        }
+        module.exports = wrap({
+            http: http,
+            https: https
+        });
+        module.exports.wrap = wrap;
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * Caron dimonio, con occhi di bragia
+ * loro accennando, tutte le raccoglie;
+ * batte col remo qualunque s’adagia 
+ *
+ * Charon the demon, with the eyes of glede,
+ * Beckoning to them, collects them all together,
+ * Beats with his oar whoever lags behind
+ *          
+ *          Dante - The Divine Comedy (Canto III)
+ */ module.exports = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy.js");
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var ProxyServer = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/index.js").Server;
+        function createProxyServer(options) {
+            return new ProxyServer(options);
+        }
+        ProxyServer.createProxyServer = createProxyServer;
+        ProxyServer.createServer = createProxyServer;
+        ProxyServer.createProxy = createProxyServer;
+        module.exports = ProxyServer;
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/common.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var common = exports, url = __webpack_require__("url"), extend = __webpack_require__("util")._extend, required = __webpack_require__("./node_modules/.pnpm/requires-port@1.0.0/node_modules/requires-port/index.js");
+        var upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i, isSSL = /^https|wss/;
+        common.isSSL = isSSL;
+        common.setupOutgoing = function(outgoing, options, req, forward) {
+            outgoing.port = options[forward || 'target'].port || (isSSL.test(options[forward || 'target'].protocol) ? 443 : 80);
+            [
+                'host',
+                'hostname',
+                'socketPath',
+                'pfx',
+                'key',
+                'passphrase',
+                'cert',
+                'ca',
+                'ciphers',
+                'secureProtocol'
+            ].forEach(function(e) {
+                outgoing[e] = options[forward || 'target'][e];
+            });
+            outgoing.method = options.method || req.method;
+            outgoing.headers = extend({}, req.headers);
+            if (options.headers) extend(outgoing.headers, options.headers);
+            if (options.auth) outgoing.auth = options.auth;
+            if (options.ca) outgoing.ca = options.ca;
+            if (isSSL.test(options[forward || 'target'].protocol)) outgoing.rejectUnauthorized = void 0 === options.secure ? true : options.secure;
+            outgoing.agent = options.agent || false;
+            outgoing.localAddress = options.localAddress;
+            if (!outgoing.agent) {
+                outgoing.headers = outgoing.headers || {};
+                if ('string' != typeof outgoing.headers.connection || !upgradeHeader.test(outgoing.headers.connection)) outgoing.headers.connection = 'close';
+            }
+            var target = options[forward || 'target'];
+            var targetPath = target && false !== options.prependPath ? target.path || '' : '';
+            var outgoingPath = options.toProxy ? req.url : url.parse(req.url).path || '';
+            outgoingPath = options.ignorePath ? '' : outgoingPath;
+            outgoing.path = common.urlJoin(targetPath, outgoingPath);
+            if (options.changeOrigin) outgoing.headers.host = required(outgoing.port, options[forward || 'target'].protocol) && !hasPort(outgoing.host) ? outgoing.host + ':' + outgoing.port : outgoing.host;
+            return outgoing;
+        };
+        common.setupSocket = function(socket) {
+            socket.setTimeout(0);
+            socket.setNoDelay(true);
+            socket.setKeepAlive(true, 0);
+            return socket;
+        };
+        common.getPort = function(req) {
+            var res = req.headers.host ? req.headers.host.match(/:(\d+)/) : '';
+            return res ? res[1] : common.hasEncryptedConnection(req) ? '443' : '80';
+        };
+        common.hasEncryptedConnection = function(req) {
+            return Boolean(req.connection.encrypted || req.connection.pair);
+        };
+        common.urlJoin = function() {
+            var args = Array.prototype.slice.call(arguments), lastIndex = args.length - 1, last = args[lastIndex], lastSegs = last.split('?'), retSegs;
+            args[lastIndex] = lastSegs.shift();
+            retSegs = [
+                args.filter(Boolean).join('/').replace(/\/+/g, '/').replace('http:/', 'http://').replace('https:/', 'https://')
+            ];
+            retSegs.push.apply(retSegs, lastSegs);
+            return retSegs.join('?');
+        };
+        common.rewriteCookieProperty = function rewriteCookieProperty(header, config, property) {
+            if (Array.isArray(header)) return header.map(function(headerElement) {
+                return rewriteCookieProperty(headerElement, config, property);
+            });
+            return header.replace(new RegExp("(;\\s*" + property + "=)([^;]+)", 'i'), function(match, prefix, previousValue) {
+                var newValue;
+                if (previousValue in config) newValue = config[previousValue];
+                else {
+                    if (!('*' in config)) return match;
+                    newValue = config['*'];
+                }
+                if (newValue) return prefix + newValue;
+                return '';
+            });
+        };
+        function hasPort(host) {
+            return !!~host.indexOf(':');
+        }
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var httpProxy = module.exports, extend = __webpack_require__("util")._extend, parse_url = __webpack_require__("url").parse, EE3 = __webpack_require__("./node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js"), http = __webpack_require__("http"), https = __webpack_require__("https"), web = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/passes/web-incoming.js"), ws = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/passes/ws-incoming.js");
+        httpProxy.Server = ProxyServer;
+        function createRightProxy(type) {
+            return function(options) {
+                return function(req, res) {
+                    var passes = 'ws' === type ? this.wsPasses : this.webPasses, args = [].slice.call(arguments), cntr = args.length - 1, head, cbl;
+                    if ('function' == typeof args[cntr]) {
+                        cbl = args[cntr];
+                        cntr--;
+                    }
+                    var requestOptions = options;
+                    if (!(args[cntr] instanceof Buffer) && args[cntr] !== res) {
+                        requestOptions = extend({}, options);
+                        extend(requestOptions, args[cntr]);
+                        cntr--;
+                    }
+                    if (args[cntr] instanceof Buffer) head = args[cntr];
+                    [
+                        'target',
+                        'forward'
+                    ].forEach(function(e) {
+                        if ('string' == typeof requestOptions[e]) requestOptions[e] = parse_url(requestOptions[e]);
+                    });
+                    if (!requestOptions.target && !requestOptions.forward) return this.emit('error', new Error('Must provide a proper URL as target'));
+                    for(var i = 0; i < passes.length && !passes[i](req, res, requestOptions, head, this, cbl); i++);
+                };
+            };
+        }
+        httpProxy.createRightProxy = createRightProxy;
+        function ProxyServer(options) {
+            EE3.call(this);
+            options = options || {};
+            options.prependPath = false !== options.prependPath;
+            this.web = this.proxyRequest = createRightProxy('web')(options);
+            this.ws = this.proxyWebsocketRequest = createRightProxy('ws')(options);
+            this.options = options;
+            this.webPasses = Object.keys(web).map(function(pass) {
+                return web[pass];
+            });
+            this.wsPasses = Object.keys(ws).map(function(pass) {
+                return ws[pass];
+            });
+            this.on('error', this.onError, this);
+        }
+        __webpack_require__("util").inherits(ProxyServer, EE3);
+        ProxyServer.prototype.onError = function(err) {
+            if (1 === this.listeners('error').length) throw err;
+        };
+        ProxyServer.prototype.listen = function(port, hostname) {
+            var self = this, closure = function(req, res) {
+                self.web(req, res);
+            };
+            this._server = this.options.ssl ? https.createServer(this.options.ssl, closure) : http.createServer(closure);
+            if (this.options.ws) this._server.on('upgrade', function(req, socket, head) {
+                self.ws(req, socket, head);
+            });
+            this._server.listen(port, hostname);
+            return this;
+        };
+        ProxyServer.prototype.close = function(callback) {
+            var self = this;
+            if (this._server) this._server.close(done);
+            function done() {
+                self._server = null;
+                if (callback) callback.apply(null, arguments);
+            }
+        };
+        ProxyServer.prototype.before = function(type, passName, callback) {
+            if ('ws' !== type && 'web' !== type) throw new Error('type must be `web` or `ws`');
+            var passes = 'ws' === type ? this.wsPasses : this.webPasses, i = false;
+            passes.forEach(function(v, idx) {
+                if (v.name === passName) i = idx;
+            });
+            if (false === i) throw new Error('No such pass');
+            passes.splice(i, 0, callback);
+        };
+        ProxyServer.prototype.after = function(type, passName, callback) {
+            if ('ws' !== type && 'web' !== type) throw new Error('type must be `web` or `ws`');
+            var passes = 'ws' === type ? this.wsPasses : this.webPasses, i = false;
+            passes.forEach(function(v, idx) {
+                if (v.name === passName) i = idx;
+            });
+            if (false === i) throw new Error('No such pass');
+            passes.splice(i++, 0, callback);
+        };
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/passes/web-incoming.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var httpNative = __webpack_require__("http"), httpsNative = __webpack_require__("https"), web_o = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/passes/web-outgoing.js"), common = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/common.js"), followRedirects = __webpack_require__("./node_modules/.pnpm/follow-redirects@1.15.9_debug@4.4.3/node_modules/follow-redirects/index.js");
+        web_o = Object.keys(web_o).map(function(pass) {
+            return web_o[pass];
+        });
+        var nativeAgents = {
+            http: httpNative,
+            https: httpsNative
+        };
+        /*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */ module.exports = {
+            deleteLength: function(req, res, options) {
+                if (('DELETE' === req.method || 'OPTIONS' === req.method) && !req.headers['content-length']) {
+                    req.headers['content-length'] = '0';
+                    delete req.headers['transfer-encoding'];
+                }
+            },
+            timeout: function(req, res, options) {
+                if (options.timeout) req.socket.setTimeout(options.timeout);
+            },
+            XHeaders: function(req, res, options) {
+                if (!options.xfwd) return;
+                var encrypted = req.isSpdy || common.hasEncryptedConnection(req);
+                var values = {
+                    for: req.connection.remoteAddress || req.socket.remoteAddress,
+                    port: common.getPort(req),
+                    proto: encrypted ? 'https' : 'http'
+                };
+                [
+                    'for',
+                    'port',
+                    'proto'
+                ].forEach(function(header) {
+                    req.headers['x-forwarded-' + header] = (req.headers['x-forwarded-' + header] || '') + (req.headers['x-forwarded-' + header] ? ',' : '') + values[header];
+                });
+                req.headers['x-forwarded-host'] = req.headers['x-forwarded-host'] || req.headers['host'] || '';
+            },
+            stream: function(req, res, options, _, server, clb) {
+                server.emit('start', req, res, options.target || options.forward);
+                var agents = options.followRedirects ? followRedirects : nativeAgents;
+                var http = agents.http;
+                var https = agents.https;
+                if (options.forward) {
+                    var forwardReq = ('https:' === options.forward.protocol ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req, 'forward'));
+                    var forwardError = createErrorHandler(forwardReq, options.forward);
+                    req.on('error', forwardError);
+                    forwardReq.on('error', forwardError);
+                    (options.buffer || req).pipe(forwardReq);
+                    if (!options.target) return res.end();
+                }
+                var proxyReq = ('https:' === options.target.protocol ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req));
+                proxyReq.on('socket', function(socket) {
+                    if (server && !proxyReq.getHeader('expect')) server.emit('proxyReq', proxyReq, req, res, options);
+                });
+                if (options.proxyTimeout) proxyReq.setTimeout(options.proxyTimeout, function() {
+                    proxyReq.abort();
+                });
+                req.on('aborted', function() {
+                    proxyReq.abort();
+                });
+                var proxyError = createErrorHandler(proxyReq, options.target);
+                req.on('error', proxyError);
+                proxyReq.on('error', proxyError);
+                function createErrorHandler(proxyReq, url) {
+                    return function(err) {
+                        if (req.socket.destroyed && 'ECONNRESET' === err.code) {
+                            server.emit('econnreset', err, req, res, url);
+                            return proxyReq.abort();
+                        }
+                        if (clb) clb(err, req, res, url);
+                        else server.emit('error', err, req, res, url);
+                    };
+                }
+                (options.buffer || req).pipe(proxyReq);
+                proxyReq.on('response', function(proxyRes) {
+                    if (server) server.emit('proxyRes', proxyRes, req, res);
+                    if (!res.headersSent && !options.selfHandleResponse) for(var i = 0; i < web_o.length && !web_o[i](req, res, proxyRes, options); i++);
+                    if (res.finished) {
+                        if (server) server.emit('end', req, res, proxyRes);
+                    } else {
+                        proxyRes.on('end', function() {
+                            if (server) server.emit('end', req, res, proxyRes);
+                        });
+                        if (!options.selfHandleResponse) proxyRes.pipe(res);
+                    }
+                });
+            }
+        };
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/passes/web-outgoing.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var url = __webpack_require__("url"), common = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/common.js");
+        var redirectRegex = /^201|30(1|2|7|8)$/;
+        /*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */ module.exports = {
+            removeChunked: function(req, res, proxyRes) {
+                if ('1.0' === req.httpVersion) delete proxyRes.headers['transfer-encoding'];
+            },
+            setConnection: function(req, res, proxyRes) {
+                if ('1.0' === req.httpVersion) proxyRes.headers.connection = req.headers.connection || 'close';
+                else if ('2.0' !== req.httpVersion && !proxyRes.headers.connection) proxyRes.headers.connection = req.headers.connection || 'keep-alive';
+            },
+            setRedirectHostRewrite: function(req, res, proxyRes, options) {
+                if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers['location'] && redirectRegex.test(proxyRes.statusCode)) {
+                    var target = url.parse(options.target);
+                    var u = url.parse(proxyRes.headers['location']);
+                    if (target.host != u.host) return;
+                    if (options.hostRewrite) u.host = options.hostRewrite;
+                    else if (options.autoRewrite) u.host = req.headers['host'];
+                    if (options.protocolRewrite) u.protocol = options.protocolRewrite;
+                    proxyRes.headers['location'] = u.format();
+                }
+            },
+            writeHeaders: function(req, res, proxyRes, options) {
+                var rewriteCookieDomainConfig = options.cookieDomainRewrite, rewriteCookiePathConfig = options.cookiePathRewrite, preserveHeaderKeyCase = options.preserveHeaderKeyCase, rawHeaderKeyMap, setHeader = function(key, header) {
+                    if (void 0 == header) return;
+                    if (rewriteCookieDomainConfig && 'set-cookie' === key.toLowerCase()) header = common.rewriteCookieProperty(header, rewriteCookieDomainConfig, 'domain');
+                    if (rewriteCookiePathConfig && 'set-cookie' === key.toLowerCase()) header = common.rewriteCookieProperty(header, rewriteCookiePathConfig, 'path');
+                    res.setHeader(String(key).trim(), header);
+                };
+                if ('string' == typeof rewriteCookieDomainConfig) rewriteCookieDomainConfig = {
+                    '*': rewriteCookieDomainConfig
+                };
+                if ('string' == typeof rewriteCookiePathConfig) rewriteCookiePathConfig = {
+                    '*': rewriteCookiePathConfig
+                };
+                if (preserveHeaderKeyCase && void 0 != proxyRes.rawHeaders) {
+                    rawHeaderKeyMap = {};
+                    for(var i = 0; i < proxyRes.rawHeaders.length; i += 2){
+                        var key = proxyRes.rawHeaders[i];
+                        rawHeaderKeyMap[key.toLowerCase()] = key;
+                    }
+                }
+                Object.keys(proxyRes.headers).forEach(function(key) {
+                    var header = proxyRes.headers[key];
+                    if (preserveHeaderKeyCase && rawHeaderKeyMap) key = rawHeaderKeyMap[key] || key;
+                    setHeader(key, header);
+                });
+            },
+            writeStatusCode: function(req, res, proxyRes) {
+                if (proxyRes.statusMessage) {
+                    res.statusCode = proxyRes.statusCode;
+                    res.statusMessage = proxyRes.statusMessage;
+                } else res.statusCode = proxyRes.statusCode;
+            }
+        };
+    },
+    "./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/passes/ws-incoming.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var http = __webpack_require__("http"), https = __webpack_require__("https"), common = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/lib/http-proxy/common.js");
+        /*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, socket, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */ module.exports = {
+            checkMethodAndHeader: function(req, socket) {
+                if ('GET' !== req.method || !req.headers.upgrade) {
+                    socket.destroy();
+                    return true;
+                }
+                if ('websocket' !== req.headers.upgrade.toLowerCase()) {
+                    socket.destroy();
+                    return true;
+                }
+            },
+            XHeaders: function(req, socket, options) {
+                if (!options.xfwd) return;
+                var values = {
+                    for: req.connection.remoteAddress || req.socket.remoteAddress,
+                    port: common.getPort(req),
+                    proto: common.hasEncryptedConnection(req) ? 'wss' : 'ws'
+                };
+                [
+                    'for',
+                    'port',
+                    'proto'
+                ].forEach(function(header) {
+                    req.headers['x-forwarded-' + header] = (req.headers['x-forwarded-' + header] || '') + (req.headers['x-forwarded-' + header] ? ',' : '') + values[header];
+                });
+            },
+            stream: function(req, socket, options, head, server, clb) {
+                var createHttpHeader = function(line, headers) {
+                    return Object.keys(headers).reduce(function(head, key) {
+                        var value = headers[key];
+                        if (!Array.isArray(value)) {
+                            head.push(key + ': ' + value);
+                            return head;
+                        }
+                        for(var i = 0; i < value.length; i++)head.push(key + ': ' + value[i]);
+                        return head;
+                    }, [
+                        line
+                    ]).join('\r\n') + '\r\n\r\n';
+                };
+                common.setupSocket(socket);
+                if (head && head.length) socket.unshift(head);
+                var proxyReq = (common.isSSL.test(options.target.protocol) ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req));
+                if (server) server.emit('proxyReqWs', proxyReq, req, socket, options, head);
+                proxyReq.on('error', onOutgoingError);
+                proxyReq.on('response', function(res) {
+                    if (!res.upgrade) {
+                        socket.write(createHttpHeader('HTTP/' + res.httpVersion + ' ' + res.statusCode + ' ' + res.statusMessage, res.headers));
+                        res.pipe(socket);
+                    }
+                });
+                proxyReq.on('upgrade', function(proxyRes, proxySocket, proxyHead) {
+                    proxySocket.on('error', onOutgoingError);
+                    proxySocket.on('end', function() {
+                        server.emit('close', proxyRes, proxySocket, proxyHead);
+                    });
+                    socket.on('error', function() {
+                        proxySocket.end();
+                    });
+                    common.setupSocket(proxySocket);
+                    if (proxyHead && proxyHead.length) proxySocket.unshift(proxyHead);
+                    socket.write(createHttpHeader('HTTP/1.1 101 Switching Protocols', proxyRes.headers));
+                    proxySocket.pipe(socket).pipe(proxySocket);
+                    server.emit('open', proxySocket);
+                    server.emit('proxySocket', proxySocket);
+                });
+                return proxyReq.end();
+                function onOutgoingError(err) {
+                    if (clb) clb(err, req, socket);
+                    else server.emit('error', err, req, socket);
+                    socket.end();
+                }
+            }
+        };
+    },
+    "./node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js" (module) {
+        /*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */ module.exports = function(str) {
+            if ('string' != typeof str || '' === str) return false;
+            var match;
+            while(match = /(\\).|([@?!+*]\(.*\))/g.exec(str)){
+                if (match[2]) return true;
+                str = str.slice(match.index + match[0].length);
+            }
+            return false;
+        };
+    },
+    "./node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */ var isExtglob = __webpack_require__("./node_modules/.pnpm/is-extglob@2.1.1/node_modules/is-extglob/index.js");
+        var chars = {
+            '{': '}',
+            '(': ')',
+            '[': ']'
+        };
+        var strictCheck = function(str) {
+            if ('!' === str[0]) return true;
+            var index = 0;
+            var pipeIndex = -2;
+            var closeSquareIndex = -2;
+            var closeCurlyIndex = -2;
+            var closeParenIndex = -2;
+            var backSlashIndex = -2;
+            while(index < str.length){
+                if ('*' === str[index]) return true;
+                if ('?' === str[index + 1] && /[\].+)]/.test(str[index])) return true;
+                if (-1 !== closeSquareIndex && '[' === str[index] && ']' !== str[index + 1]) {
+                    if (closeSquareIndex < index) closeSquareIndex = str.indexOf(']', index);
+                    if (closeSquareIndex > index) {
+                        if (-1 === backSlashIndex || backSlashIndex > closeSquareIndex) return true;
+                        backSlashIndex = str.indexOf('\\', index);
+                        if (-1 === backSlashIndex || backSlashIndex > closeSquareIndex) return true;
+                    }
+                }
+                if (-1 !== closeCurlyIndex && '{' === str[index] && '}' !== str[index + 1]) {
+                    closeCurlyIndex = str.indexOf('}', index);
+                    if (closeCurlyIndex > index) {
+                        backSlashIndex = str.indexOf('\\', index);
+                        if (-1 === backSlashIndex || backSlashIndex > closeCurlyIndex) return true;
+                    }
+                }
+                if (-1 !== closeParenIndex && '(' === str[index] && '?' === str[index + 1] && /[:!=]/.test(str[index + 2]) && ')' !== str[index + 3]) {
+                    closeParenIndex = str.indexOf(')', index);
+                    if (closeParenIndex > index) {
+                        backSlashIndex = str.indexOf('\\', index);
+                        if (-1 === backSlashIndex || backSlashIndex > closeParenIndex) return true;
+                    }
+                }
+                if (-1 !== pipeIndex && '(' === str[index] && '|' !== str[index + 1]) {
+                    if (pipeIndex < index) pipeIndex = str.indexOf('|', index);
+                    if (-1 !== pipeIndex && ')' !== str[pipeIndex + 1]) {
+                        closeParenIndex = str.indexOf(')', pipeIndex);
+                        if (closeParenIndex > pipeIndex) {
+                            backSlashIndex = str.indexOf('\\', pipeIndex);
+                            if (-1 === backSlashIndex || backSlashIndex > closeParenIndex) return true;
+                        }
+                    }
+                }
+                if ('\\' === str[index]) {
+                    var open = str[index + 1];
+                    index += 2;
+                    var close = chars[open];
+                    if (close) {
+                        var n = str.indexOf(close, index);
+                        if (-1 !== n) index = n + 1;
+                    }
+                    if ('!' === str[index]) return true;
+                } else index++;
+            }
+            return false;
+        };
+        var relaxedCheck = function(str) {
+            if ('!' === str[0]) return true;
+            var index = 0;
+            while(index < str.length){
+                if (/[*?{}()[\]]/.test(str[index])) return true;
+                if ('\\' === str[index]) {
+                    var open = str[index + 1];
+                    index += 2;
+                    var close = chars[open];
+                    if (close) {
+                        var n = str.indexOf(close, index);
+                        if (-1 !== n) index = n + 1;
+                    }
+                    if ('!' === str[index]) return true;
+                } else index++;
+            }
+            return false;
+        };
+        module.exports = function(str, options) {
+            if ('string' != typeof str || '' === str) return false;
+            if (isExtglob(str)) return true;
+            var check = strictCheck;
+            if (options && false === options.strict) check = relaxedCheck;
+            return check(str);
+        };
+    },
+    "./node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js" (module) {
+        /*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */ module.exports = function(num) {
+            if ('number' == typeof num) return num - num === 0;
+            if ('string' == typeof num && '' !== num.trim()) return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+            return false;
+        };
+    },
+    "./node_modules/.pnpm/is-plain-object@5.0.0/node_modules/is-plain-object/dist/is-plain-object.js" (__unused_rspack_module, exports) {
+        /*!
+ * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */ function isObject(o) {
+            return '[object Object]' === Object.prototype.toString.call(o);
+        }
+        function isPlainObject(o) {
+            var ctor, prot;
+            if (false === isObject(o)) return false;
+            ctor = o.constructor;
+            if (void 0 === ctor) return true;
+            prot = ctor.prototype;
+            if (false === isObject(prot)) return false;
+            if (false === prot.hasOwnProperty('isPrototypeOf')) return false;
+            return true;
+        }
+        exports.isPlainObject = isPlainObject;
+    },
+    "./node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const util = __webpack_require__("util");
+        const braces = __webpack_require__("./node_modules/.pnpm/braces@3.0.3/node_modules/braces/index.js");
+        const picomatch = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js");
+        const isEmptyString = (v)=>'' === v || './' === v;
+        const hasBraces = (v)=>{
+            const index = v.indexOf('{');
+            return index > -1 && v.indexOf('}', index) > -1;
+        };
+        const micromatch = (list, patterns, options)=>{
+            patterns = [].concat(patterns);
+            list = [].concat(list);
+            let omit = new Set();
+            let keep = new Set();
+            let items = new Set();
+            let negatives = 0;
+            let onResult = (state)=>{
+                items.add(state.output);
+                if (options && options.onResult) options.onResult(state);
+            };
+            for(let i = 0; i < patterns.length; i++){
+                let isMatch = picomatch(String(patterns[i]), {
+                    ...options,
+                    onResult
+                }, true);
+                let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+                if (negated) negatives++;
+                for (let item of list){
+                    let matched = isMatch(item, true);
+                    let match = negated ? !matched.isMatch : matched.isMatch;
+                    if (match) if (negated) omit.add(matched.output);
+                    else {
+                        omit.delete(matched.output);
+                        keep.add(matched.output);
+                    }
+                }
+            }
+            let result = negatives === patterns.length ? [
+                ...items
+            ] : [
+                ...keep
+            ];
+            let matches = result.filter((item)=>!omit.has(item));
+            if (options && 0 === matches.length) {
+                if (true === options.failglob) throw new Error(`No matches found for "${patterns.join(', ')}"`);
+                if (true === options.nonull || true === options.nullglob) return options.unescape ? patterns.map((p)=>p.replace(/\\/g, '')) : patterns;
+            }
+            return matches;
+        };
+        micromatch.match = micromatch;
+        micromatch.matcher = (pattern, options)=>picomatch(pattern, options);
+        micromatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        micromatch.any = micromatch.isMatch;
+        micromatch.not = (list, patterns, options = {})=>{
+            patterns = [].concat(patterns).map(String);
+            let result = new Set();
+            let items = [];
+            let onResult = (state)=>{
+                if (options.onResult) options.onResult(state);
+                items.push(state.output);
+            };
+            let matches = new Set(micromatch(list, patterns, {
+                ...options,
+                onResult
+            }));
+            for (let item of items)if (!matches.has(item)) result.add(item);
+            return [
+                ...result
+            ];
+        };
+        micromatch.contains = (str, pattern, options)=>{
+            if ('string' != typeof str) throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+            if (Array.isArray(pattern)) return pattern.some((p)=>micromatch.contains(str, p, options));
+            if ('string' == typeof pattern) {
+                if (isEmptyString(str) || isEmptyString(pattern)) return false;
+                if (str.includes(pattern) || str.startsWith('./') && str.slice(2).includes(pattern)) return true;
+            }
+            return micromatch.isMatch(str, pattern, {
+                ...options,
+                contains: true
+            });
+        };
+        micromatch.matchKeys = (obj, patterns, options)=>{
+            if (!utils.isObject(obj)) throw new TypeError('Expected the first argument to be an object');
+            let keys = micromatch(Object.keys(obj), patterns, options);
+            let res = {};
+            for (let key of keys)res[key] = obj[key];
+            return res;
+        };
+        micromatch.some = (list, patterns, options)=>{
+            let items = [].concat(list);
+            for (let pattern of [].concat(patterns)){
+                let isMatch = picomatch(String(pattern), options);
+                if (items.some((item)=>isMatch(item))) return true;
+            }
+            return false;
+        };
+        micromatch.every = (list, patterns, options)=>{
+            let items = [].concat(list);
+            for (let pattern of [].concat(patterns)){
+                let isMatch = picomatch(String(pattern), options);
+                if (!items.every((item)=>isMatch(item))) return false;
+            }
+            return true;
+        };
+        micromatch.all = (str, patterns, options)=>{
+            if ('string' != typeof str) throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+            return [].concat(patterns).every((p)=>picomatch(p, options)(str));
+        };
+        micromatch.capture = (glob, input, options)=>{
+            let posix = utils.isWindows(options);
+            let regex = picomatch.makeRe(String(glob), {
+                ...options,
+                capture: true
+            });
+            let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+            if (match) return match.slice(1).map((v)=>void 0 === v ? '' : v);
+        };
+        micromatch.makeRe = (...args)=>picomatch.makeRe(...args);
+        micromatch.scan = (...args)=>picomatch.scan(...args);
+        micromatch.parse = (patterns, options)=>{
+            let res = [];
+            for (let pattern of [].concat(patterns || []))for (let str of braces(String(pattern), options))res.push(picomatch.parse(str, options));
+            return res;
+        };
+        micromatch.braces = (pattern, options)=>{
+            if ('string' != typeof pattern) throw new TypeError('Expected a string');
+            if (options && true === options.nobrace || !hasBraces(pattern)) return [
+                pattern
+            ];
+            return braces(pattern, options);
+        };
+        micromatch.braceExpand = (pattern, options)=>{
+            if ('string' != typeof pattern) throw new TypeError('Expected a string');
+            return micromatch.braces(pattern, {
+                ...options,
+                expand: true
+            });
+        };
+        micromatch.hasBraces = hasBraces;
+        module.exports = micromatch;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js");
+    },
+    "./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const WIN_SLASH = '\\\\/';
+        const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        const DOT_LITERAL = '\\.';
+        const PLUS_LITERAL = '\\+';
+        const QMARK_LITERAL = '\\?';
+        const SLASH_LITERAL = '\\/';
+        const ONE_CHAR = '(?=.)';
+        const QMARK = '[^/]';
+        const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+        const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+        const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+        const NO_DOT = `(?!${DOT_LITERAL})`;
+        const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+        const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+        const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+        const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+        const STAR = `${QMARK}*?`;
+        const 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
+        };
+        const WINDOWS_CHARS = {
+            ...POSIX_CHARS,
+            SLASH_LITERAL: `[${WIN_SLASH}]`,
+            QMARK: WIN_NO_SLASH,
+            STAR: `${WIN_NO_SLASH}*?`,
+            DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+            NO_DOT: `(?!${DOT_LITERAL})`,
+            NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+            NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+            QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+            START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+            END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+        };
+        const 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'
+        };
+        module.exports = {
+            MAX_LENGTH: 65536,
+            POSIX_REGEX_SOURCE,
+            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: {
+                '***': '*',
+                '**/**': '**',
+                '**/**/**': '**'
+            },
+            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,
+            SEP: path.sep,
+            extglobChars (chars) {
+                return {
+                    '!': {
+                        type: 'negate',
+                        open: '(?:(?!(?:',
+                        close: `))${chars.STAR})`
+                    },
+                    '?': {
+                        type: 'qmark',
+                        open: '(?:',
+                        close: ')?'
+                    },
+                    '+': {
+                        type: 'plus',
+                        open: '(?:',
+                        close: ')+'
+                    },
+                    '*': {
+                        type: 'star',
+                        open: '(?:',
+                        close: ')*'
+                    },
+                    '@': {
+                        type: 'at',
+                        open: '(?:',
+                        close: ')'
+                    }
+                };
+            },
+            globChars (win32) {
+                return true === win32 ? WINDOWS_CHARS : POSIX_CHARS;
+            }
+        };
+    },
+    "./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js");
+        const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+        const expandRange = (args, options)=>{
+            if ('function' == typeof options.expandRange) return options.expandRange(...args, options);
+            args.sort();
+            const value = `[${args.join('-')}]`;
+            try {
+                new RegExp(value);
+            } catch (ex) {
+                return args.map((v)=>utils.escapeRegex(v)).join('..');
+            }
+            return value;
+        };
+        const syntaxError = (type, char)=>`Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        const parse = (input, options)=>{
+            if ('string' != typeof input) throw new TypeError('Expected a string');
+            input = REPLACEMENTS[input] || input;
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            let len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            const bos = {
+                type: 'bos',
+                value: '',
+                output: opts.prepend || ''
+            };
+            const tokens = [
+                bos
+            ];
+            const capture = opts.capture ? '' : '?:';
+            const win32 = utils.isWindows(options);
+            const PLATFORM_CHARS = constants.globChars(win32);
+            const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+            const { 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;
+            const globstar = (opts)=>`(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            const nodot = opts.dot ? '' : NO_DOT;
+            const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+            let star = true === opts.bash ? globstar(opts) : STAR;
+            if (opts.capture) star = `(${star})`;
+            if ('boolean' == typeof opts.noext) opts.noextglob = opts.noext;
+            const state = {
+                input,
+                index: -1,
+                start: 0,
+                dot: true === opts.dot,
+                consumed: '',
+                output: '',
+                prefix: '',
+                backtrack: false,
+                negated: false,
+                brackets: 0,
+                braces: 0,
+                parens: 0,
+                quotes: 0,
+                globstar: false,
+                tokens
+            };
+            input = utils.removePrefix(input, state);
+            len = input.length;
+            const extglobs = [];
+            const braces = [];
+            const stack = [];
+            let prev = bos;
+            let value;
+            const eos = ()=>state.index === len - 1;
+            const peek = state.peek = (n = 1)=>input[state.index + n];
+            const advance = state.advance = ()=>input[++state.index] || '';
+            const remaining = ()=>input.slice(state.index + 1);
+            const consume = (value = '', num = 0)=>{
+                state.consumed += value;
+                state.index += num;
+            };
+            const append = (token)=>{
+                state.output += null != token.output ? token.output : token.value;
+                consume(token.value);
+            };
+            const negate = ()=>{
+                let count = 1;
+                while('!' === peek() && ('(' !== peek(2) || '?' === peek(3))){
+                    advance();
+                    state.start++;
+                    count++;
+                }
+                if (count % 2 === 0) return false;
+                state.negated = true;
+                state.start++;
+                return true;
+            };
+            const increment = (type)=>{
+                state[type]++;
+                stack.push(type);
+            };
+            const decrement = (type)=>{
+                state[type]--;
+                stack.pop();
+            };
+            const push = (tok)=>{
+                if ('globstar' === prev.type) {
+                    const isBrace = state.braces > 0 && ('comma' === tok.type || 'brace' === tok.type);
+                    const isExtglob = true === tok.extglob || extglobs.length && ('pipe' === tok.type || 'paren' === tok.type);
+                    if ('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;
+                if (tok.value || tok.output) append(tok);
+                if (prev && 'text' === prev.type && 'text' === tok.type) {
+                    prev.value += tok.value;
+                    prev.output = (prev.output || '') + tok.value;
+                    return;
+                }
+                tok.prev = prev;
+                tokens.push(tok);
+                prev = tok;
+            };
+            const extglobOpen = (type, value)=>{
+                const token = {
+                    ...EXTGLOB_CHARS[value],
+                    conditions: 1,
+                    inner: ''
+                };
+                token.prev = prev;
+                token.parens = state.parens;
+                token.output = state.output;
+                const output = (opts.capture ? '(' : '') + token.open;
+                increment('parens');
+                push({
+                    type,
+                    value,
+                    output: state.output ? '' : ONE_CHAR
+                });
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value: advance(),
+                    output
+                });
+                extglobs.push(token);
+            };
+            const extglobClose = (token)=>{
+                let output = token.close + (opts.capture ? ')' : '');
+                let rest;
+                if ('negate' === token.type) {
+                    let extglobStar = star;
+                    if (token.inner && token.inner.length > 1 && token.inner.includes('/')) extglobStar = globstar(opts);
+                    if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
+                    if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                        const expression = parse(rest, {
+                            ...options,
+                            fastpaths: false
+                        }).output;
+                        output = token.close = `)${expression})${extglobStar})`;
+                    }
+                    if ('bos' === token.prev.type) state.negatedExtglob = true;
+                }
+                push({
+                    type: 'paren',
+                    extglob: true,
+                    value,
+                    output
+                });
+                decrement('parens');
+            };
+            if (false !== opts.fastpaths && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+                let backslashes = false;
+                let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index)=>{
+                    if ('\\' === first) {
+                        backslashes = true;
+                        return m;
+                    }
+                    if ('?' === first) {
+                        if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+                        if (0 === index) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+                        return QMARK.repeat(chars.length);
+                    }
+                    if ('.' === first) return DOT_LITERAL.repeat(chars.length);
+                    if ('*' === first) {
+                        if (esc) return esc + first + (rest ? star : '');
+                        return star;
+                    }
+                    return esc ? m : `\\${m}`;
+                });
+                if (true === backslashes) output = true === opts.unescape ? output.replace(/\\/g, '') : output.replace(/\\+/g, (m)=>m.length % 2 === 0 ? '\\\\' : m ? '\\' : '');
+                if (output === input && true === opts.contains) {
+                    state.output = input;
+                    return state;
+                }
+                state.output = utils.wrapOutput(output, state, options);
+                return state;
+            }
+            while(!eos()){
+                value = advance();
+                if ('\u0000' === value) continue;
+                if ('\\' === value) {
+                    const next = peek();
+                    if ('/' === next && true !== opts.bash) continue;
+                    if ('.' === next || ';' === next) continue;
+                    if (!next) {
+                        value += '\\';
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                    const match = /^\\+/.exec(remaining());
+                    let slashes = 0;
+                    if (match && match[0].length > 2) {
+                        slashes = match[0].length;
+                        state.index += slashes;
+                        if (slashes % 2 !== 0) value += '\\';
+                    }
+                    if (true === opts.unescape) value = advance();
+                    else value += advance();
+                    if (0 === state.brackets) {
+                        push({
+                            type: 'text',
+                            value
+                        });
+                        continue;
+                    }
+                }
+                if (state.brackets > 0 && (']' !== value || '[' === prev.value || '[^' === prev.value)) {
+                    if (false !== opts.posix && ':' === value) {
+                        const inner = prev.value.slice(1);
+                        if (inner.includes('[')) {
+                            prev.posix = true;
+                            if (inner.includes(':')) {
+                                const idx = prev.value.lastIndexOf('[');
+                                const pre = prev.value.slice(0, idx);
+                                const rest = prev.value.slice(idx + 2);
+                                const posix = POSIX_REGEX_SOURCE[rest];
+                                if (posix) {
+                                    prev.value = pre + posix;
+                                    state.backtrack = true;
+                                    advance();
+                                    if (!bos.output && 1 === tokens.indexOf(prev)) bos.output = ONE_CHAR;
+                                    continue;
+                                }
+                            }
+                        }
+                    }
+                    if ('[' === value && ':' !== peek() || '-' === value && ']' === peek()) value = `\\${value}`;
+                    if (']' === value && ('[' === prev.value || '[^' === prev.value)) value = `\\${value}`;
+                    if (true === 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 : 1;
+                    if (true === opts.keepQuotes) push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('(' === value) {
+                    increment('parens');
+                    push({
+                        type: 'paren',
+                        value
+                    });
+                    continue;
+                }
+                if (')' === value) {
+                    if (0 === state.parens && true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '('));
+                    const 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 (true !== opts.nobracket && remaining().includes(']')) increment('brackets');
+                    else {
+                        if (true !== opts.nobracket && true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                        value = `\\${value}`;
+                    }
+                    push({
+                        type: 'bracket',
+                        value
+                    });
+                    continue;
+                }
+                if (']' === value) {
+                    if (true === opts.nobracket || prev && 'bracket' === prev.type && 1 === prev.value.length) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    if (0 === state.brackets) {
+                        if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('opening', '['));
+                        push({
+                            type: 'text',
+                            value,
+                            output: `\\${value}`
+                        });
+                        continue;
+                    }
+                    decrement('brackets');
+                    const prevValue = prev.value.slice(1);
+                    if (true !== prev.posix && '^' === prevValue[0] && !prevValue.includes('/')) value = `/${value}`;
+                    prev.value += value;
+                    append({
+                        value
+                    });
+                    if (false === opts.literalBrackets || utils.hasRegexChars(prevValue)) continue;
+                    const escaped = utils.escapeRegex(prev.value);
+                    state.output = state.output.slice(0, -prev.value.length);
+                    if (true === opts.literalBrackets) {
+                        state.output += escaped;
+                        prev.value = escaped;
+                        continue;
+                    }
+                    prev.value = `(${capture}${escaped}|${prev.value})`;
+                    state.output += prev.value;
+                    continue;
+                }
+                if ('{' === value && true !== opts.nobrace) {
+                    increment('braces');
+                    const open = {
+                        type: 'brace',
+                        value,
+                        output: '(',
+                        outputIndex: state.output.length,
+                        tokensIndex: state.tokens.length
+                    };
+                    braces.push(open);
+                    push(open);
+                    continue;
+                }
+                if ('}' === value) {
+                    const brace = braces[braces.length - 1];
+                    if (true === opts.nobrace || !brace) {
+                        push({
+                            type: 'text',
+                            value,
+                            output: value
+                        });
+                        continue;
+                    }
+                    let output = ')';
+                    if (true === brace.dots) {
+                        const arr = tokens.slice();
+                        const range = [];
+                        for(let i = arr.length - 1; i >= 0; i--){
+                            tokens.pop();
+                            if ('brace' === arr[i].type) break;
+                            if ('dots' !== arr[i].type) range.unshift(arr[i].value);
+                        }
+                        output = expandRange(range, opts);
+                        state.backtrack = true;
+                    }
+                    if (true !== brace.comma && true !== brace.dots) {
+                        const out = state.output.slice(0, brace.outputIndex);
+                        const toks = state.tokens.slice(brace.tokensIndex);
+                        brace.value = brace.output = '\\{';
+                        value = output = '\\}';
+                        state.output = out;
+                        for (const t of toks)state.output += t.output || t.value;
+                    }
+                    push({
+                        type: 'brace',
+                        value,
+                        output
+                    });
+                    decrement('braces');
+                    braces.pop();
+                    continue;
+                }
+                if ('|' === value) {
+                    if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (',' === value) {
+                    let output = value;
+                    const brace = braces[braces.length - 1];
+                    if (brace && 'braces' === stack[stack.length - 1]) {
+                        brace.comma = true;
+                        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) {
+                        if ('.' === prev.value) prev.output = DOT_LITERAL;
+                        const brace = braces[braces.length - 1];
+                        prev.type = 'dots';
+                        prev.output += value;
+                        prev.value += value;
+                        brace.dots = true;
+                        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) {
+                    const isGroup = prev && '(' === prev.value;
+                    if (!isGroup && true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('qmark', value);
+                        continue;
+                    }
+                    if (prev && 'paren' === prev.type) {
+                        const next = peek();
+                        let output = value;
+                        if ('<' === next && !utils.supportsLookbehinds()) throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+                        if ('(' === prev.value && !/[!=<:]/.test(next) || '<' === next && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+                        push({
+                            type: 'text',
+                            value,
+                            output
+                        });
+                        continue;
+                    }
+                    if (true !== 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 (true !== opts.noextglob && '(' === peek()) {
+                        if ('?' !== peek(2) || !/[!=<:]/.test(peek(3))) {
+                            extglobOpen('negate', value);
+                            continue;
+                        }
+                    }
+                    if (true !== opts.nonegate && 0 === state.index) {
+                        negate();
+                        continue;
+                    }
+                }
+                if ('+' === value) {
+                    if (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        extglobOpen('plus', value);
+                        continue;
+                    }
+                    if (prev && '(' === prev.value || false === 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 (true !== opts.noextglob && '(' === peek() && '?' !== peek(2)) {
+                        push({
+                            type: 'at',
+                            extglob: true,
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if ('*' !== value) {
+                    if ('$' === value || '^' === value) value = `\\${value}`;
+                    const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+                    if (match) {
+                        value += match[0];
+                        state.index += match[0].length;
+                    }
+                    push({
+                        type: 'text',
+                        value
+                    });
+                    continue;
+                }
+                if (prev && ('globstar' === prev.type || true === prev.star)) {
+                    prev.type = 'star';
+                    prev.star = true;
+                    prev.value += value;
+                    prev.output = star;
+                    state.backtrack = true;
+                    state.globstar = true;
+                    consume(value);
+                    continue;
+                }
+                let rest = remaining();
+                if (true !== opts.noextglob && /^\([^?]/.test(rest)) {
+                    extglobOpen('star', value);
+                    continue;
+                }
+                if ('star' === prev.type) {
+                    if (true === opts.noglobstar) {
+                        consume(value);
+                        continue;
+                    }
+                    const prior = prev.prev;
+                    const before = prior.prev;
+                    const isStart = 'slash' === prior.type || 'bos' === prior.type;
+                    const afterStar = before && ('star' === before.type || 'globstar' === before.type);
+                    if (true === opts.bash && (!isStart || rest[0] && '/' !== rest[0])) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    const isBrace = state.braces > 0 && ('comma' === prior.type || 'brace' === prior.type);
+                    const isExtglob = extglobs.length && ('pipe' === prior.type || 'paren' === prior.type);
+                    if (!isStart && 'paren' !== prior.type && !isBrace && !isExtglob) {
+                        push({
+                            type: 'star',
+                            value,
+                            output: ''
+                        });
+                        continue;
+                    }
+                    while('/**' === rest.slice(0, 3)){
+                        const 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 = true;
+                        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 = true;
+                        state.output += prior.output + prev.output;
+                        consume(value);
+                        continue;
+                    }
+                    if ('slash' === prior.type && 'bos' !== prior.prev.type && '/' === rest[0]) {
+                        const 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 = true;
+                        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 = true;
+                        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 = true;
+                    consume(value);
+                    continue;
+                }
+                const token = {
+                    type: 'star',
+                    value,
+                    output: star
+                };
+                if (true === opts.bash) {
+                    token.output = '.*?';
+                    if ('bos' === prev.type || 'slash' === prev.type) token.output = nodot + token.output;
+                    push(token);
+                    continue;
+                }
+                if (prev && ('bracket' === prev.type || 'paren' === prev.type) && true === opts.regex) {
+                    token.output = value;
+                    push(token);
+                    continue;
+                }
+                if (state.index === state.start || 'slash' === prev.type || 'dot' === prev.type) {
+                    if ('dot' === prev.type) {
+                        state.output += NO_DOT_SLASH;
+                        prev.output += NO_DOT_SLASH;
+                    } else if (true === opts.dot) {
+                        state.output += NO_DOTS_SLASH;
+                        prev.output += NO_DOTS_SLASH;
+                    } else {
+                        state.output += nodot;
+                        prev.output += nodot;
+                    }
+                    if ('*' !== peek()) {
+                        state.output += ONE_CHAR;
+                        prev.output += ONE_CHAR;
+                    }
+                }
+                push(token);
+            }
+            while(state.brackets > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ']'));
+                state.output = utils.escapeLast(state.output, '[');
+                decrement('brackets');
+            }
+            while(state.parens > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', ')'));
+                state.output = utils.escapeLast(state.output, '(');
+                decrement('parens');
+            }
+            while(state.braces > 0){
+                if (true === opts.strictBrackets) throw new SyntaxError(syntaxError('closing', '}'));
+                state.output = utils.escapeLast(state.output, '{');
+                decrement('braces');
+            }
+            if (true !== opts.strictSlashes && ('star' === prev.type || 'bracket' === prev.type)) push({
+                type: 'maybe_slash',
+                value: '',
+                output: `${SLASH_LITERAL}?`
+            });
+            if (true === state.backtrack) {
+                state.output = '';
+                for (const token of state.tokens){
+                    state.output += null != token.output ? token.output : token.value;
+                    if (token.suffix) state.output += token.suffix;
+                }
+            }
+            return state;
+        };
+        parse.fastpaths = (input, options)=>{
+            const opts = {
+                ...options
+            };
+            const max = 'number' == typeof opts.maxLength ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+            const len = input.length;
+            if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+            input = REPLACEMENTS[input] || input;
+            const win32 = utils.isWindows(options);
+            const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(win32);
+            const nodot = opts.dot ? NO_DOTS : NO_DOT;
+            const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+            const capture = opts.capture ? '' : '?:';
+            const state = {
+                negated: false,
+                prefix: ''
+            };
+            let star = true === opts.bash ? '.*?' : STAR;
+            if (opts.capture) star = `(${star})`;
+            const globstar = (opts)=>{
+                if (true === opts.noglobstar) return star;
+                return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+            };
+            const 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:
+                        {
+                            const match = /^(.*?)\.(\w+)$/.exec(str);
+                            if (!match) return;
+                            const source = create(match[1]);
+                            if (!source) return;
+                            return source + DOT_LITERAL + match[2];
+                        }
+                }
+            };
+            const output = utils.removePrefix(input, state);
+            let source = create(output);
+            if (source && true !== opts.strictSlashes) source += `${SLASH_LITERAL}?`;
+            return source;
+        };
+        module.exports = parse;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const scan = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js");
+        const parse = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js");
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js");
+        const constants = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js");
+        const isObject = (val)=>val && 'object' == typeof val && !Array.isArray(val);
+        const picomatch = (glob, options, returnState = false)=>{
+            if (Array.isArray(glob)) {
+                const fns = glob.map((input)=>picomatch(input, options, returnState));
+                const arrayMatcher = (str)=>{
+                    for (const isMatch of fns){
+                        const state = isMatch(str);
+                        if (state) return state;
+                    }
+                    return false;
+                };
+                return arrayMatcher;
+            }
+            const isState = isObject(glob) && glob.tokens && glob.input;
+            if ('' === glob || 'string' != typeof glob && !isState) throw new TypeError('Expected pattern to be a non-empty string');
+            const opts = options || {};
+            const posix = utils.isWindows(options);
+            const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+            const state = regex.state;
+            delete regex.state;
+            let isIgnored = ()=>false;
+            if (opts.ignore) {
+                const ignoreOpts = {
+                    ...options,
+                    ignore: null,
+                    onMatch: null,
+                    onResult: null
+                };
+                isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+            }
+            const matcher = (input, returnObject = false)=>{
+                const { isMatch, match, output } = picomatch.test(input, regex, options, {
+                    glob,
+                    posix
+                });
+                const result = {
+                    glob,
+                    state,
+                    regex,
+                    posix,
+                    input,
+                    output,
+                    match,
+                    isMatch
+                };
+                if ('function' == typeof opts.onResult) opts.onResult(result);
+                if (false === isMatch) {
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if (isIgnored(input)) {
+                    if ('function' == typeof opts.onIgnore) opts.onIgnore(result);
+                    result.isMatch = false;
+                    return returnObject ? result : false;
+                }
+                if ('function' == typeof opts.onMatch) opts.onMatch(result);
+                return returnObject ? result : true;
+            };
+            if (returnState) matcher.state = state;
+            return matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {})=>{
+            if ('string' != typeof input) throw new TypeError('Expected input to be a string');
+            if ('' === input) return {
+                isMatch: false,
+                output: ''
+            };
+            const opts = options || {};
+            const format = opts.format || (posix ? utils.toPosixSlashes : null);
+            let match = input === glob;
+            let output = match && format ? format(input) : input;
+            if (false === match) {
+                output = format ? format(input) : input;
+                match = output === glob;
+            }
+            if (false === match || true === opts.capture) match = true === opts.matchBase || true === opts.basename ? picomatch.matchBase(input, regex, options, posix) : regex.exec(output);
+            return {
+                isMatch: Boolean(match),
+                match,
+                output
+            };
+        };
+        picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options))=>{
+            const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+            return regex.test(path.basename(input));
+        };
+        picomatch.isMatch = (str, patterns, options)=>picomatch(patterns, options)(str);
+        picomatch.parse = (pattern, options)=>{
+            if (Array.isArray(pattern)) return pattern.map((p)=>picomatch.parse(p, options));
+            return parse(pattern, {
+                ...options,
+                fastpaths: false
+            });
+        };
+        picomatch.scan = (input, options)=>scan(input, options);
+        picomatch.compileRe = (state, options, returnOutput = false, returnState = false)=>{
+            if (true === returnOutput) return state.output;
+            const opts = options || {};
+            const prepend = opts.contains ? '' : '^';
+            const append = opts.contains ? '' : '$';
+            let source = `${prepend}(?:${state.output})${append}`;
+            if (state && true === state.negated) source = `^(?!${source}).*$`;
+            const regex = picomatch.toRegex(source, options);
+            if (true === returnState) regex.state = state;
+            return regex;
+        };
+        picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false)=>{
+            if (!input || 'string' != typeof input) throw new TypeError('Expected a non-empty string');
+            let parsed = {
+                negated: false,
+                fastpaths: true
+            };
+            if (false !== options.fastpaths && ('.' === input[0] || '*' === input[0])) parsed.output = parse.fastpaths(input, options);
+            if (!parsed.output) parsed = parse(input, options);
+            return picomatch.compileRe(parsed, options, returnOutput, returnState);
+        };
+        picomatch.toRegex = (source, options)=>{
+            try {
+                const opts = options || {};
+                return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+            } catch (err) {
+                if (options && true === options.debug) throw err;
+                return /$^/;
+            }
+        };
+        picomatch.constants = constants;
+        module.exports = picomatch;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const utils = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js");
+        const { 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@2.3.1/node_modules/picomatch/lib/constants.js");
+        const isPathSeparator = (code)=>code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        const depth = (token)=>{
+            if (true !== token.isPrefix) token.depth = token.isGlobstar ? 1 / 0 : 1;
+        };
+        const scan = (input, options)=>{
+            const opts = options || {};
+            const length = input.length - 1;
+            const scanToEnd = true === opts.parts || true === opts.scanToEnd;
+            const slashes = [];
+            const tokens = [];
+            const parts = [];
+            let str = input;
+            let index = -1;
+            let start = 0;
+            let lastIndex = 0;
+            let isBrace = false;
+            let isBracket = false;
+            let isGlob = false;
+            let isExtglob = false;
+            let isGlobstar = false;
+            let braceEscaped = false;
+            let backslashes = false;
+            let negated = false;
+            let negatedExtglob = false;
+            let finished = false;
+            let braces = 0;
+            let prev;
+            let code;
+            let token = {
+                value: '',
+                depth: 0,
+                isGlob: false
+            };
+            const eos = ()=>index >= length;
+            const peek = ()=>str.charCodeAt(index + 1);
+            const advance = ()=>{
+                prev = code;
+                return str.charCodeAt(++index);
+            };
+            while(index < length){
+                code = advance();
+                let next;
+                if (code === CHAR_BACKWARD_SLASH) {
+                    backslashes = token.backslashes = true;
+                    code = advance();
+                    if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
+                    continue;
+                }
+                if (true === braceEscaped || code === CHAR_LEFT_CURLY_BRACE) {
+                    braces++;
+                    while(true !== eos() && (code = advance())){
+                        if (code === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (code === CHAR_LEFT_CURLY_BRACE) {
+                            braces++;
+                            continue;
+                        }
+                        if (true !== braceEscaped && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (true !== braceEscaped && code === CHAR_COMMA) {
+                            isBrace = token.isBrace = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            if (true === scanToEnd) continue;
+                            break;
+                        }
+                        if (code === CHAR_RIGHT_CURLY_BRACE) {
+                            braces--;
+                            if (0 === braces) {
+                                braceEscaped = false;
+                                isBrace = token.isBrace = true;
+                                finished = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_FORWARD_SLASH) {
+                    slashes.push(index);
+                    tokens.push(token);
+                    token = {
+                        value: '',
+                        depth: 0,
+                        isGlob: false
+                    };
+                    if (true === finished) continue;
+                    if (prev === CHAR_DOT && index === start + 1) {
+                        start += 2;
+                        continue;
+                    }
+                    lastIndex = index + 1;
+                    continue;
+                }
+                if (true !== opts.noext) {
+                    const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+                    if (true === isExtglobChar && peek() === CHAR_LEFT_PARENTHESES) {
+                        isGlob = token.isGlob = true;
+                        isExtglob = token.isExtglob = true;
+                        finished = true;
+                        if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+                        if (true === scanToEnd) {
+                            while(true !== eos() && (code = advance())){
+                                if (code === CHAR_BACKWARD_SLASH) {
+                                    backslashes = token.backslashes = true;
+                                    code = advance();
+                                    continue;
+                                }
+                                if (code === CHAR_RIGHT_PARENTHESES) {
+                                    isGlob = token.isGlob = true;
+                                    finished = true;
+                                    break;
+                                }
+                            }
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                if (code === CHAR_ASTERISK) {
+                    if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_QUESTION_MARK) {
+                    isGlob = token.isGlob = true;
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (code === CHAR_LEFT_SQUARE_BRACKET) {
+                    while(true !== eos() && (next = advance())){
+                        if (next === CHAR_BACKWARD_SLASH) {
+                            backslashes = token.backslashes = true;
+                            advance();
+                            continue;
+                        }
+                        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                            isBracket = token.isBracket = true;
+                            isGlob = token.isGlob = true;
+                            finished = true;
+                            break;
+                        }
+                    }
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+                if (true !== opts.nonegate && code === CHAR_EXCLAMATION_MARK && index === start) {
+                    negated = token.negated = true;
+                    start++;
+                    continue;
+                }
+                if (true !== opts.noparen && code === CHAR_LEFT_PARENTHESES) {
+                    isGlob = token.isGlob = true;
+                    if (true === scanToEnd) {
+                        while(true !== eos() && (code = advance())){
+                            if (code === CHAR_LEFT_PARENTHESES) {
+                                backslashes = token.backslashes = true;
+                                code = advance();
+                                continue;
+                            }
+                            if (code === CHAR_RIGHT_PARENTHESES) {
+                                finished = true;
+                                break;
+                            }
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                if (true === isGlob) {
+                    finished = true;
+                    if (true === scanToEnd) continue;
+                    break;
+                }
+            }
+            if (true === opts.noext) {
+                isExtglob = false;
+                isGlob = false;
+            }
+            let base = str;
+            let prefix = '';
+            let glob = '';
+            if (start > 0) {
+                prefix = str.slice(0, start);
+                str = str.slice(start);
+                lastIndex -= start;
+            }
+            if (base && true === isGlob && lastIndex > 0) {
+                base = str.slice(0, lastIndex);
+                glob = str.slice(lastIndex);
+            } else if (true === isGlob) {
+                base = '';
+                glob = str;
+            } else base = str;
+            if (base && '' !== base && '/' !== base && base !== str) {
+                if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
+            }
+            if (true === opts.unescape) {
+                if (glob) glob = utils.removeBackslashes(glob);
+                if (base && true === backslashes) base = utils.removeBackslashes(base);
+            }
+            const state = {
+                prefix,
+                input,
+                start,
+                base,
+                glob,
+                isBrace,
+                isBracket,
+                isGlob,
+                isExtglob,
+                isGlobstar,
+                negated,
+                negatedExtglob
+            };
+            if (true === opts.tokens) {
+                state.maxDepth = 0;
+                if (!isPathSeparator(code)) tokens.push(token);
+                state.tokens = tokens;
+            }
+            if (true === opts.parts || true === opts.tokens) {
+                let prevIndex;
+                for(let idx = 0; idx < slashes.length; idx++){
+                    const n = prevIndex ? prevIndex + 1 : start;
+                    const i = slashes[idx];
+                    const value = input.slice(n, i);
+                    if (opts.tokens) {
+                        if (0 === idx && 0 !== start) {
+                            tokens[idx].isPrefix = true;
+                            tokens[idx].value = prefix;
+                        } else tokens[idx].value = value;
+                        depth(tokens[idx]);
+                        state.maxDepth += tokens[idx].depth;
+                    }
+                    if (0 !== idx || '' !== value) parts.push(value);
+                    prevIndex = i;
+                }
+                if (prevIndex && prevIndex + 1 < input.length) {
+                    const value = input.slice(prevIndex + 1);
+                    parts.push(value);
+                    if (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;
+        };
+        module.exports = scan;
+    },
+    "./node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js" (__unused_rspack_module, exports, __webpack_require__) {
+        const path = __webpack_require__("path");
+        const win32 = 'win32' === process.platform;
+        const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = __webpack_require__("./node_modules/.pnpm/picomatch@2.3.1/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.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match);
+        exports.supportsLookbehinds = ()=>{
+            const segs = process.version.slice(1).split('.').map(Number);
+            if (3 === segs.length && segs[0] >= 9 || 8 === segs[0] && segs[1] >= 10) return true;
+            return false;
+        };
+        exports.isWindows = (options)=>{
+            if (options && 'boolean' == typeof options.windows) return options.windows;
+            return true === win32 || '\\' === path.sep;
+        };
+        exports.escapeLast = (input, char, lastIdx)=>{
+            const idx = input.lastIndexOf(char, lastIdx);
+            if (-1 === idx) return input;
+            if ('\\' === input[idx - 1]) return exports.escapeLast(input, char, idx - 1);
+            return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        };
+        exports.removePrefix = (input, state = {})=>{
+            let output = input;
+            if (output.startsWith('./')) {
+                output = output.slice(2);
+                state.prefix = './';
+            }
+            return output;
+        };
+        exports.wrapOutput = (input, state = {}, options = {})=>{
+            const prepend = options.contains ? '' : '^';
+            const append = options.contains ? '' : '$';
+            let output = `${prepend}(?:${input})${append}`;
+            if (true === state.negated) output = `(?:^(?!${output}).*$)`;
+            return output;
+        };
+    },
+    "./node_modules/.pnpm/requires-port@1.0.0/node_modules/requires-port/index.js" (module) {
+        module.exports = function(port, protocol) {
+            protocol = protocol.split(':')[0];
+            port *= 1;
+            if (!port) return false;
+            switch(protocol){
+                case 'http':
+                case 'ws':
+                    return 80 !== port;
+                case 'https':
+                case 'wss':
+                    return 443 !== port;
+                case 'ftp':
+                    return 21 !== port;
+                case 'gopher':
+                    return 70 !== port;
+                case 'file':
+                    return false;
+            }
+            return 0 !== port;
+        };
+    },
+    "./node_modules/.pnpm/to-regex-range@5.0.1/node_modules/to-regex-range/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        /*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */ const isNumber = __webpack_require__("./node_modules/.pnpm/is-number@7.0.0/node_modules/is-number/index.js");
+        const toRegexRange = (min, max, options)=>{
+            if (false === isNumber(min)) throw new TypeError('toRegexRange: expected the first argument to be a number');
+            if (void 0 === max || min === max) return String(min);
+            if (false === isNumber(max)) throw new TypeError('toRegexRange: expected the second argument to be a number.');
+            let opts = {
+                relaxZeros: true,
+                ...options
+            };
+            if ('boolean' == typeof opts.strictZeros) opts.relaxZeros = false === opts.strictZeros;
+            let relax = String(opts.relaxZeros);
+            let shorthand = String(opts.shorthand);
+            let capture = String(opts.capture);
+            let wrap = String(opts.wrap);
+            let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
+            if (toRegexRange.cache.hasOwnProperty(cacheKey)) return toRegexRange.cache[cacheKey].result;
+            let a = Math.min(min, max);
+            let b = Math.max(min, max);
+            if (1 === Math.abs(a - b)) {
+                let result = min + '|' + max;
+                if (opts.capture) return `(${result})`;
+                if (false === opts.wrap) return result;
+                return `(?:${result})`;
+            }
+            let isPadded = hasPadding(min) || hasPadding(max);
+            let state = {
+                min,
+                max,
+                a,
+                b
+            };
+            let positives = [];
+            let negatives = [];
+            if (isPadded) {
+                state.isPadded = isPadded;
+                state.maxLen = String(state.max).length;
+            }
+            if (a < 0) {
+                let newMin = b < 0 ? Math.abs(b) : 1;
+                negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
+                a = state.a = 0;
+            }
+            if (b >= 0) positives = splitToPatterns(a, b, state, opts);
+            state.negatives = negatives;
+            state.positives = positives;
+            state.result = collatePatterns(negatives, positives, opts);
+            if (true === opts.capture) state.result = `(${state.result})`;
+            else if (false !== opts.wrap && positives.length + negatives.length > 1) state.result = `(?:${state.result})`;
+            toRegexRange.cache[cacheKey] = state;
+            return state.result;
+        };
+        function collatePatterns(neg, pos, options) {
+            let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];
+            let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];
+            let intersected = filterPatterns(neg, pos, '-?', true, options) || [];
+            let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
+            return subpatterns.join('|');
+        }
+        function splitToRanges(min, max) {
+            let nines = 1;
+            let zeros = 1;
+            let stop = countNines(min, nines);
+            let stops = new Set([
+                max
+            ]);
+            while(min <= stop && stop <= max){
+                stops.add(stop);
+                nines += 1;
+                stop = countNines(min, nines);
+            }
+            stop = countZeros(max + 1, zeros) - 1;
+            while(min < stop && stop <= max){
+                stops.add(stop);
+                zeros += 1;
+                stop = countZeros(max + 1, zeros) - 1;
+            }
+            stops = [
+                ...stops
+            ];
+            stops.sort(compare);
+            return stops;
+        }
+        function rangeToPattern(start, stop, options) {
+            if (start === stop) return {
+                pattern: start,
+                count: [],
+                digits: 0
+            };
+            let zipped = zip(start, stop);
+            let digits = zipped.length;
+            let pattern = '';
+            let count = 0;
+            for(let i = 0; i < digits; i++){
+                let [startDigit, stopDigit] = zipped[i];
+                if (startDigit === stopDigit) pattern += startDigit;
+                else if ('0' !== startDigit || '9' !== stopDigit) pattern += toCharacterClass(startDigit, stopDigit, options);
+                else count++;
+            }
+            if (count) pattern += true === options.shorthand ? '\\d' : '[0-9]';
+            return {
+                pattern,
+                count: [
+                    count
+                ],
+                digits
+            };
+        }
+        function splitToPatterns(min, max, tok, options) {
+            let ranges = splitToRanges(min, max);
+            let tokens = [];
+            let start = min;
+            let prev;
+            for(let i = 0; i < ranges.length; i++){
+                let max = ranges[i];
+                let obj = rangeToPattern(String(start), String(max), options);
+                let zeros = '';
+                if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+                    if (prev.count.length > 1) prev.count.pop();
+                    prev.count.push(obj.count[0]);
+                    prev.string = prev.pattern + toQuantifier(prev.count);
+                    start = max + 1;
+                    continue;
+                }
+                if (tok.isPadded) zeros = padZeros(max, tok, options);
+                obj.string = zeros + obj.pattern + toQuantifier(obj.count);
+                tokens.push(obj);
+                start = max + 1;
+                prev = obj;
+            }
+            return tokens;
+        }
+        function filterPatterns(arr, comparison, prefix, intersection, options) {
+            let result = [];
+            for (let ele of arr){
+                let { string } = ele;
+                if (!intersection && !contains(comparison, 'string', string)) result.push(prefix + string);
+                if (intersection && contains(comparison, 'string', string)) result.push(prefix + string);
+            }
+            return result;
+        }
+        function zip(a, b) {
+            let arr = [];
+            for(let i = 0; i < a.length; i++)arr.push([
+                a[i],
+                b[i]
+            ]);
+            return arr;
+        }
+        function compare(a, b) {
+            return a > b ? 1 : b > a ? -1 : 0;
+        }
+        function contains(arr, key, val) {
+            return arr.some((ele)=>ele[key] === val);
+        }
+        function countNines(min, len) {
+            return Number(String(min).slice(0, -len) + '9'.repeat(len));
+        }
+        function countZeros(integer, zeros) {
+            return integer - integer % Math.pow(10, zeros);
+        }
+        function toQuantifier(digits) {
+            let [start = 0, stop = ''] = digits;
+            if (stop || start > 1) return `{${start + (stop ? ',' + stop : '')}}`;
+            return '';
+        }
+        function toCharacterClass(a, b, options) {
+            return `[${a}${b - a === 1 ? '' : '-'}${b}]`;
+        }
+        function hasPadding(str) {
+            return /^-?(0+)\d/.test(str);
+        }
+        function padZeros(value, tok, options) {
+            if (!tok.isPadded) return value;
+            let diff = Math.abs(tok.maxLen - String(value).length);
+            let relax = false !== options.relaxZeros;
+            switch(diff){
+                case 0:
+                    return '';
+                case 1:
+                    return relax ? '0?' : '0';
+                case 2:
+                    return relax ? '0{0,2}' : '00';
+                default:
+                    return relax ? `0{0,${diff}}` : `0{${diff}}`;
+            }
+        }
+        toRegexRange.cache = {};
+        toRegexRange.clearCache = ()=>toRegexRange.cache = {};
+        module.exports = toRegexRange;
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/configuration.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.verifyConfig = verifyConfig;
+        const errors_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/errors.js");
+        function verifyConfig(options) {
+            if (!options.target && !options.router) throw new Error(errors_1.ERRORS.ERR_CONFIG_FACTORY_TARGET_MISSING);
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.Debug = void 0;
+        const createDebug = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js");
+        exports.Debug = createDebug('http-proxy-middleware');
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/errors.js" (__unused_rspack_module, exports) {
+        exports.ERRORS = void 0;
+        var ERRORS;
+        (function(ERRORS) {
+            ERRORS["ERR_CONFIG_FACTORY_TARGET_MISSING"] = "[HPM] Missing \"target\" option. Example: {target: \"http://www.example.org\"}";
+            ERRORS["ERR_CONTEXT_MATCHER_GENERIC"] = "[HPM] Invalid pathFilter. Expecting something like: \"/api\" or [\"/api\", \"/ajax\"]";
+            ERRORS["ERR_CONTEXT_MATCHER_INVALID_ARRAY"] = "[HPM] Invalid pathFilter. Plain paths (e.g. \"/api\") can not be mixed with globs (e.g. \"/api/**\"). Expecting something like: [\"/api\", \"/ajax\"] or [\"/api/**\", \"!**.html\"].";
+            ERRORS["ERR_PATH_REWRITER_CONFIG"] = "[HPM] Invalid pathRewrite config. Expecting object with pathRewrite config or a rewrite function";
+        })(ERRORS || (exports.ERRORS = ERRORS = {}));
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/factory.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.createProxyMiddleware = createProxyMiddleware;
+        const http_proxy_middleware_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/http-proxy-middleware.js");
+        function createProxyMiddleware(options) {
+            const { middleware } = new http_proxy_middleware_1.HttpProxyMiddleware(options);
+            return middleware;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/get-plugins.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.getPlugins = getPlugins;
+        const default_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/index.js");
+        function getPlugins(options) {
+            const maybeErrorResponsePlugin = options.on?.error ? [] : [
+                default_1.errorResponsePlugin
+            ];
+            const defaultPlugins = options.ejectPlugins ? [] : [
+                default_1.debugProxyErrorsPlugin,
+                default_1.proxyEventsPlugin,
+                default_1.loggerPlugin,
+                ...maybeErrorResponsePlugin
+            ];
+            const userPlugins = options.plugins ?? [];
+            return [
+                ...defaultPlugins,
+                ...userPlugins
+            ];
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/fix-request-body.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.fixRequestBody = fixRequestBody;
+        const querystring = __webpack_require__("querystring");
+        function fixRequestBody(proxyReq, req) {
+            if (0 !== req.readableLength) return;
+            const requestBody = req.body;
+            if (!requestBody) return;
+            const contentType = proxyReq.getHeader('Content-Type');
+            if (!contentType) return;
+            const writeBody = (bodyData)=>{
+                proxyReq.setHeader('Content-Length', Buffer.byteLength(bodyData));
+                proxyReq.write(bodyData);
+            };
+            if (contentType.includes('application/json') || contentType.includes('+json')) writeBody(JSON.stringify(requestBody));
+            else if (contentType.includes('application/x-www-form-urlencoded')) writeBody(querystring.stringify(requestBody));
+            else if (contentType.includes('multipart/form-data')) writeBody(handlerFormDataBodyData(contentType, requestBody));
+        }
+        function handlerFormDataBodyData(contentType, data) {
+            const boundary = contentType.replace(/^.*boundary=(.*)$/, '$1');
+            let str = '';
+            for (const [key, value] of Object.entries(data))str += `--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`;
+            return str;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+                enumerable: true,
+                get: function() {
+                    return m[k];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)if ("default" !== p && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/public.js"), exports);
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/public.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.fixRequestBody = exports.responseInterceptor = void 0;
+        var response_interceptor_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/response-interceptor.js");
+        Object.defineProperty(exports, "responseInterceptor", {
+            enumerable: true,
+            get: function() {
+                return response_interceptor_1.responseInterceptor;
+            }
+        });
+        var fix_request_body_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/fix-request-body.js");
+        Object.defineProperty(exports, "fixRequestBody", {
+            enumerable: true,
+            get: function() {
+                return fix_request_body_1.fixRequestBody;
+            }
+        });
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/response-interceptor.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.responseInterceptor = responseInterceptor;
+        const zlib = __webpack_require__("zlib");
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const function_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/utils/function.js");
+        const debug = debug_1.Debug.extend('response-interceptor');
+        function responseInterceptor(interceptor) {
+            return async function(proxyRes, req, res) {
+                debug('intercept proxy response');
+                const originalProxyRes = proxyRes;
+                let buffer = Buffer.from('', 'utf8');
+                const _proxyRes = decompress(proxyRes, proxyRes.headers['content-encoding']);
+                _proxyRes.on('data', (chunk)=>buffer = Buffer.concat([
+                        buffer,
+                        chunk
+                    ]));
+                _proxyRes.on('end', async ()=>{
+                    copyHeaders(proxyRes, res);
+                    debug('call interceptor function: %s', (0, function_1.getFunctionName)(interceptor));
+                    const interceptedBuffer = Buffer.from(await interceptor(buffer, originalProxyRes, req, res));
+                    debug('set content-length: %s', Buffer.byteLength(interceptedBuffer, 'utf8'));
+                    res.setHeader('content-length', Buffer.byteLength(interceptedBuffer, 'utf8'));
+                    debug('write intercepted response');
+                    res.write(interceptedBuffer);
+                    res.end();
+                });
+                _proxyRes.on('error', (error)=>{
+                    res.end(`Error fetching proxied request: ${error.message}`);
+                });
+            };
+        }
+        function decompress(proxyRes, contentEncoding) {
+            let _proxyRes = proxyRes;
+            let decompress;
+            switch(contentEncoding){
+                case 'gzip':
+                    decompress = zlib.createGunzip();
+                    break;
+                case 'br':
+                    decompress = zlib.createBrotliDecompress();
+                    break;
+                case 'deflate':
+                    decompress = zlib.createInflate();
+                    break;
+                default:
+                    break;
+            }
+            if (decompress) {
+                debug("decompress proxy response with 'content-encoding': %s", contentEncoding);
+                _proxyRes.pipe(decompress);
+                _proxyRes = decompress;
+            }
+            return _proxyRes;
+        }
+        function copyHeaders(originalResponse, response) {
+            debug('copy original response headers');
+            response.statusCode = originalResponse.statusCode;
+            response.statusMessage = originalResponse.statusMessage;
+            if (response.setHeader) {
+                let keys = Object.keys(originalResponse.headers);
+                keys = keys.filter((key)=>![
+                        'content-encoding',
+                        'transfer-encoding'
+                    ].includes(key));
+                keys.forEach((key)=>{
+                    let value = originalResponse.headers[key];
+                    if ('set-cookie' === key) {
+                        value = Array.isArray(value) ? value : [
+                            value
+                        ];
+                        value = value.map((x)=>x.replace(/Domain=[^;]+?/i, ''));
+                    }
+                    response.setHeader(key, value);
+                });
+            } else response.headers = originalResponse.headers;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/http-proxy-middleware.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.HttpProxyMiddleware = void 0;
+        const httpProxy = __webpack_require__("./node_modules/.pnpm/http-proxy@1.18.1_debug@4.4.3/node_modules/http-proxy/index.js");
+        const configuration_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/configuration.js");
+        const get_plugins_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/get-plugins.js");
+        const path_filter_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/path-filter.js");
+        const PathRewriter = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/path-rewriter.js");
+        const Router = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/router.js");
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const function_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/utils/function.js");
+        const logger_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/logger.js");
+        class HttpProxyMiddleware {
+            constructor(options){
+                this.wsInternalSubscribed = false;
+                this.serverOnCloseSubscribed = false;
+                this.middleware = async (req, res, next)=>{
+                    if (this.shouldProxy(this.proxyOptions.pathFilter, req)) try {
+                        const activeProxyOptions = await this.prepareProxyRequest(req);
+                        (0, debug_1.Debug)("proxy request to target: %O", activeProxyOptions.target);
+                        this.proxy.web(req, res, activeProxyOptions);
+                    } catch (err) {
+                        next?.(err);
+                    }
+                    else next?.();
+                    const server = (req.socket ?? req.connection)?.server;
+                    if (server && !this.serverOnCloseSubscribed) {
+                        server.on('close', ()=>{
+                            (0, debug_1.Debug)('server close signal received: closing proxy server');
+                            this.proxy.close();
+                        });
+                        this.serverOnCloseSubscribed = true;
+                    }
+                    if (true === this.proxyOptions.ws) this.catchUpgradeRequest(server);
+                };
+                this.catchUpgradeRequest = (server)=>{
+                    if (!this.wsInternalSubscribed) {
+                        (0, debug_1.Debug)('subscribing to server upgrade event');
+                        server.on('upgrade', this.handleUpgrade);
+                        this.wsInternalSubscribed = true;
+                    }
+                };
+                this.handleUpgrade = async (req, socket, head)=>{
+                    try {
+                        if (this.shouldProxy(this.proxyOptions.pathFilter, req)) {
+                            const activeProxyOptions = await this.prepareProxyRequest(req);
+                            this.proxy.ws(req, socket, head, activeProxyOptions);
+                            (0, debug_1.Debug)('server upgrade event received. Proxying WebSocket');
+                        }
+                    } catch (err) {
+                        this.proxy.emit('error', err, req, socket);
+                    }
+                };
+                this.shouldProxy = (pathFilter, req)=>{
+                    try {
+                        return (0, path_filter_1.matchPathFilter)(pathFilter, req.url, req);
+                    } catch (err) {
+                        (0, debug_1.Debug)('Error: matchPathFilter() called with request url: ', `"${req.url}"`);
+                        this.logger.error(err);
+                        return false;
+                    }
+                };
+                this.prepareProxyRequest = async (req)=>{
+                    if (this.middleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__) req.url = req.originalUrl || req.url;
+                    const newProxyOptions = Object.assign({}, this.proxyOptions);
+                    await this.applyRouter(req, newProxyOptions);
+                    await this.applyPathRewrite(req, this.pathRewriter);
+                    return newProxyOptions;
+                };
+                this.applyRouter = async (req, options)=>{
+                    let newTarget;
+                    if (options.router) {
+                        newTarget = await Router.getTarget(req, options);
+                        if (newTarget) {
+                            (0, debug_1.Debug)('router new target: "%s"', newTarget);
+                            options.target = newTarget;
+                        }
+                    }
+                };
+                this.applyPathRewrite = async (req, pathRewriter)=>{
+                    if (pathRewriter) {
+                        const path = await pathRewriter(req.url, req);
+                        if ('string' == typeof path) {
+                            (0, debug_1.Debug)('pathRewrite new path: %s', req.url);
+                            req.url = path;
+                        } else (0, debug_1.Debug)('pathRewrite: no rewritten path found: %s', req.url);
+                    }
+                };
+                (0, configuration_1.verifyConfig)(options);
+                this.proxyOptions = options;
+                this.logger = (0, logger_1.getLogger)(options);
+                (0, debug_1.Debug)("create proxy server");
+                this.proxy = httpProxy.createProxyServer({});
+                this.registerPlugins(this.proxy, this.proxyOptions);
+                this.pathRewriter = PathRewriter.createPathRewriter(this.proxyOptions.pathRewrite);
+                this.middleware.upgrade = (req, socket, head)=>{
+                    if (!this.wsInternalSubscribed) this.handleUpgrade(req, socket, head);
+                };
+            }
+            registerPlugins(proxy, options) {
+                const plugins = (0, get_plugins_1.getPlugins)(options);
+                plugins.forEach((plugin)=>{
+                    (0, debug_1.Debug)(`register plugin: "${(0, function_1.getFunctionName)(plugin)}"`);
+                    plugin(proxy, options);
+                });
+            }
+        }
+        exports.HttpProxyMiddleware = HttpProxyMiddleware;
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+                enumerable: true,
+                get: function() {
+                    return m[k];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)if ("default" !== p && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/factory.js"), exports);
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/handlers/index.js"), exports);
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/index.js"), exports);
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/index.js"), exports);
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/create-proxy-middleware.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.legacyCreateProxyMiddleware = legacyCreateProxyMiddleware;
+        const factory_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/factory.js");
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const options_adapter_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/options-adapter.js");
+        const debug = debug_1.Debug.extend('legacy-create-proxy-middleware');
+        function legacyCreateProxyMiddleware(legacyContext, legacyOptions) {
+            debug('init');
+            const options = (0, options_adapter_1.legacyOptionsAdapter)(legacyContext, legacyOptions);
+            const proxyMiddleware = (0, factory_1.createProxyMiddleware)(options);
+            debug('add marker for patching req.url (old behavior)');
+            proxyMiddleware.__LEGACY_HTTP_PROXY_MIDDLEWARE__ = true;
+            return proxyMiddleware;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+                enumerable: true,
+                get: function() {
+                    return m[k];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)if ("default" !== p && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/public.js"), exports);
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/options-adapter.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.legacyOptionsAdapter = legacyOptionsAdapter;
+        const url = __webpack_require__("url");
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const logger_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/logger.js");
+        const debug = debug_1.Debug.extend('legacy-options-adapter');
+        const proxyEventMap = {
+            onError: 'error',
+            onProxyReq: 'proxyReq',
+            onProxyRes: 'proxyRes',
+            onProxyReqWs: 'proxyReqWs',
+            onOpen: 'open',
+            onClose: 'close'
+        };
+        function legacyOptionsAdapter(legacyContext, legacyOptions) {
+            let options = {};
+            let logger;
+            if ('string' == typeof legacyContext && !!url.parse(legacyContext).host) throw new Error(`Shorthand syntax is removed from legacyCreateProxyMiddleware().
+      Please use "legacyCreateProxyMiddleware({ target: 'http://www.example.org' })" instead.
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-shorthand-usage
+      `);
+            if (legacyContext && legacyOptions) {
+                debug('map legacy context/filter to options.pathFilter');
+                options = {
+                    ...legacyOptions,
+                    pathFilter: legacyContext
+                };
+                logger = getLegacyLogger(options);
+                logger.warn(`[http-proxy-middleware] Legacy "context" argument is deprecated. Migrate your "context" to "options.pathFilter":
+
+      const options = {
+        pathFilter: '${legacyContext}',
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-context-argument
+      `);
+            } else if (legacyContext && !legacyOptions) {
+                options = {
+                    ...legacyContext
+                };
+                logger = getLegacyLogger(options);
+            } else logger = getLegacyLogger({});
+            Object.entries(proxyEventMap).forEach(([legacyEventName, proxyEventName])=>{
+                if (options[legacyEventName]) {
+                    options.on = {
+                        ...options.on
+                    };
+                    options.on[proxyEventName] = options[legacyEventName];
+                    debug('map legacy event "%s" to "on.%s"', legacyEventName, proxyEventName);
+                    logger.warn(`[http-proxy-middleware] Legacy "${legacyEventName}" is deprecated. Migrate to "options.on.${proxyEventName}":
+
+        const options = {
+          on: {
+            ${proxyEventName}: () => {},
+          },
+        }
+
+        More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#refactored-proxy-events
+        `);
+                }
+            });
+            const logProvider = options.logProvider && options.logProvider();
+            const logLevel = options.logLevel;
+            debug('legacy logLevel', logLevel);
+            debug('legacy logProvider: %O', logProvider);
+            if ('string' == typeof logLevel && 'silent' !== logLevel) {
+                debug('map "logProvider" to "logger"');
+                logger.warn(`[http-proxy-middleware] Legacy "logLevel" and "logProvider" are deprecated. Migrate to "options.logger":
+
+      const options = {
+        logger: console,
+      }
+
+      More details: https://github.com/chimurai/http-proxy-middleware/blob/master/MIGRATION.md#removed-logprovider-and-loglevel-options
+      `);
+            }
+            return options;
+        }
+        function getLegacyLogger(options) {
+            const legacyLogger = options.logProvider && options.logProvider();
+            if (legacyLogger) options.logger = legacyLogger;
+            return (0, logger_1.getLogger)(options);
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/public.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.legacyCreateProxyMiddleware = void 0;
+        var create_proxy_middleware_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/legacy/create-proxy-middleware.js");
+        Object.defineProperty(exports, "legacyCreateProxyMiddleware", {
+            enumerable: true,
+            get: function() {
+                return create_proxy_middleware_1.legacyCreateProxyMiddleware;
+            }
+        });
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/logger.js" (__unused_rspack_module, exports) {
+        exports.getLogger = getLogger;
+        const noopLogger = {
+            info: ()=>{},
+            warn: ()=>{},
+            error: ()=>{}
+        };
+        function getLogger(options) {
+            return options.logger || noopLogger;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/path-filter.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.matchPathFilter = matchPathFilter;
+        const isGlob = __webpack_require__("./node_modules/.pnpm/is-glob@4.0.3/node_modules/is-glob/index.js");
+        const micromatch = __webpack_require__("./node_modules/.pnpm/micromatch@4.0.8/node_modules/micromatch/index.js");
+        const url = __webpack_require__("url");
+        const errors_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/errors.js");
+        function matchPathFilter(pathFilter = '/', uri, req) {
+            if (isStringPath(pathFilter)) return matchSingleStringPath(pathFilter, uri);
+            if (isGlobPath(pathFilter)) return matchSingleGlobPath(pathFilter, uri);
+            if (Array.isArray(pathFilter)) {
+                if (pathFilter.every(isStringPath)) return matchMultiPath(pathFilter, uri);
+                if (pathFilter.every(isGlobPath)) return matchMultiGlobPath(pathFilter, uri);
+                throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_INVALID_ARRAY);
+            }
+            if ('function' == typeof pathFilter) {
+                const pathname = getUrlPathName(uri);
+                return pathFilter(pathname, req);
+            }
+            throw new Error(errors_1.ERRORS.ERR_CONTEXT_MATCHER_GENERIC);
+        }
+        function matchSingleStringPath(pathFilter, uri) {
+            const pathname = getUrlPathName(uri);
+            return pathname?.indexOf(pathFilter) === 0;
+        }
+        function matchSingleGlobPath(pattern, uri) {
+            const pathname = getUrlPathName(uri);
+            const matches = micromatch([
+                pathname
+            ], pattern);
+            return matches && matches.length > 0;
+        }
+        function matchMultiGlobPath(patternList, uri) {
+            return matchSingleGlobPath(patternList, uri);
+        }
+        function matchMultiPath(pathFilterList, uri) {
+            let isMultiPath = false;
+            for (const context of pathFilterList)if (matchSingleStringPath(context, uri)) {
+                isMultiPath = true;
+                break;
+            }
+            return isMultiPath;
+        }
+        function getUrlPathName(uri) {
+            return uri && url.parse(uri).pathname;
+        }
+        function isStringPath(pathFilter) {
+            return 'string' == typeof pathFilter && !isGlob(pathFilter);
+        }
+        function isGlobPath(pathFilter) {
+            return isGlob(pathFilter);
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/path-rewriter.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.createPathRewriter = createPathRewriter;
+        const is_plain_object_1 = __webpack_require__("./node_modules/.pnpm/is-plain-object@5.0.0/node_modules/is-plain-object/dist/is-plain-object.js");
+        const errors_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/errors.js");
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const debug = debug_1.Debug.extend('path-rewriter');
+        function createPathRewriter(rewriteConfig) {
+            let rulesCache;
+            if (!isValidRewriteConfig(rewriteConfig)) return;
+            if ('function' == typeof rewriteConfig) {
+                const customRewriteFn = rewriteConfig;
+                return customRewriteFn;
+            }
+            rulesCache = parsePathRewriteRules(rewriteConfig);
+            return rewritePath;
+            function rewritePath(path) {
+                let result = path;
+                for (const rule of rulesCache)if (rule.regex.test(path)) {
+                    result = result.replace(rule.regex, rule.value);
+                    debug('rewriting path from "%s" to "%s"', path, result);
+                    break;
+                }
+                return result;
+            }
+        }
+        function isValidRewriteConfig(rewriteConfig) {
+            if ('function' == typeof rewriteConfig) return true;
+            if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) return 0 !== Object.keys(rewriteConfig).length;
+            if (null == rewriteConfig) return false;
+            throw new Error(errors_1.ERRORS.ERR_PATH_REWRITER_CONFIG);
+        }
+        function parsePathRewriteRules(rewriteConfig) {
+            const rules = [];
+            if ((0, is_plain_object_1.isPlainObject)(rewriteConfig)) for (const [key, value] of Object.entries(rewriteConfig)){
+                rules.push({
+                    regex: new RegExp(key),
+                    value: value
+                });
+                debug('rewrite rule created: "%s" ~> "%s"', key, value);
+            }
+            return rules;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/debug-proxy-errors-plugin.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.debugProxyErrorsPlugin = void 0;
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const debug = debug_1.Debug.extend('debug-proxy-errors-plugin');
+        const debugProxyErrorsPlugin = (proxyServer)=>{
+            proxyServer.on('error', (error, req, res, target)=>{
+                debug(`http-proxy error event: \n%O`, error);
+            });
+            proxyServer.on('proxyReq', (proxyReq, req, socket)=>{
+                socket.on('error', (error)=>{
+                    debug('Socket error in proxyReq event: \n%O', error);
+                });
+            });
+            proxyServer.on('proxyRes', (proxyRes, req, res)=>{
+                res.on('close', ()=>{
+                    if (!res.writableEnded) {
+                        debug('Destroying proxyRes in proxyRes close event');
+                        proxyRes.destroy();
+                    }
+                });
+            });
+            proxyServer.on('proxyReqWs', (proxyReq, req, socket)=>{
+                socket.on('error', (error)=>{
+                    debug('Socket error in proxyReqWs event: \n%O', error);
+                });
+            });
+            proxyServer.on('open', (proxySocket)=>{
+                proxySocket.on('error', (error)=>{
+                    debug('Socket error in open event: \n%O', error);
+                });
+            });
+            proxyServer.on('close', (req, socket, head)=>{
+                socket.on('error', (error)=>{
+                    debug('Socket error in close event: \n%O', error);
+                });
+            });
+            proxyServer.on('econnreset', (error, req, res, target)=>{
+                debug(`http-proxy econnreset event: \n%O`, error);
+            });
+        };
+        exports.debugProxyErrorsPlugin = debugProxyErrorsPlugin;
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/error-response-plugin.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.errorResponsePlugin = void 0;
+        const status_code_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/status-code.js");
+        function isResponseLike(obj) {
+            return obj && 'function' == typeof obj.writeHead;
+        }
+        function isSocketLike(obj) {
+            return obj && 'function' == typeof obj.write && !('writeHead' in obj);
+        }
+        const errorResponsePlugin = (proxyServer, options)=>{
+            proxyServer.on('error', (err, req, res, target)=>{
+                if (!req && !res) throw err;
+                if (isResponseLike(res)) {
+                    if (!res.headersSent) {
+                        const statusCode = (0, status_code_1.getStatusCode)(err.code);
+                        res.writeHead(statusCode);
+                    }
+                    const host = req.headers && req.headers.host;
+                    res.end(`Error occurred while trying to proxy: ${host}${req.url}`);
+                } else if (isSocketLike(res)) res.destroy();
+            });
+        };
+        exports.errorResponsePlugin = errorResponsePlugin;
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/index.js" (__unused_rspack_module, exports, __webpack_require__) {
+        var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+                enumerable: true,
+                get: function() {
+                    return m[k];
+                }
+            };
+            Object.defineProperty(o, k2, desc);
+        } : function(o, m, k, k2) {
+            if (void 0 === k2) k2 = k;
+            o[k2] = m[k];
+        });
+        var __exportStar = this && this.__exportStar || function(m, exports) {
+            for(var p in m)if ("default" !== p && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/debug-proxy-errors-plugin.js"), exports);
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/error-response-plugin.js"), exports);
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/logger-plugin.js"), exports);
+        __exportStar(__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/proxy-events.js"), exports);
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/logger-plugin.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.loggerPlugin = void 0;
+        const url_1 = __webpack_require__("url");
+        const logger_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/logger.js");
+        const logger_plugin_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/utils/logger-plugin.js");
+        const loggerPlugin = (proxyServer, options)=>{
+            const logger = (0, logger_1.getLogger)(options);
+            proxyServer.on('error', (err, req, res, target)=>{
+                const hostname = req?.headers?.host;
+                const requestHref = `${hostname}${req?.url}`;
+                const targetHref = `${target?.href}`;
+                const errorMessage = '[HPM] Error occurred while proxying request %s to %s [%s] (%s)';
+                const errReference = 'https://nodejs.org/api/errors.html#errors_common_system_errors';
+                logger.error(errorMessage, requestHref, targetHref, err.code || err, errReference);
+            });
+            proxyServer.on('proxyRes', (proxyRes, req, res)=>{
+                const originalUrl = req.originalUrl ?? `${req.baseUrl || ''}${req.url}`;
+                let target;
+                try {
+                    const port = (0, logger_plugin_1.getPort)(proxyRes.req?.agent?.sockets);
+                    const obj = {
+                        protocol: proxyRes.req.protocol,
+                        host: proxyRes.req.host,
+                        pathname: proxyRes.req.path
+                    };
+                    target = new url_1.URL(`${obj.protocol}//${obj.host}${obj.pathname}`);
+                    if (port) target.port = port;
+                } catch (err) {
+                    target = new url_1.URL(options.target);
+                    target.pathname = proxyRes.req.path;
+                }
+                const targetUrl = target.toString();
+                const exchange = `[HPM] ${req.method} ${originalUrl} -> ${targetUrl} [${proxyRes.statusCode}]`;
+                logger.info(exchange);
+            });
+            proxyServer.on('open', (socket)=>{
+                logger.info('[HPM] Client connected: %o', socket.address());
+            });
+            proxyServer.on('close', (req, proxySocket, proxyHead)=>{
+                logger.info('[HPM] Client disconnected: %o', proxySocket.address());
+            });
+        };
+        exports.loggerPlugin = loggerPlugin;
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/plugins/default/proxy-events.js" (__unused_rspack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        exports.proxyEventsPlugin = void 0;
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const function_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/utils/function.js");
+        const debug = debug_1.Debug.extend('proxy-events-plugin');
+        const proxyEventsPlugin = (proxyServer, options)=>{
+            Object.entries(options.on || {}).forEach(([eventName, handler])=>{
+                debug(`register event handler: "${eventName}" -> "${(0, function_1.getFunctionName)(handler)}"`);
+                proxyServer.on(eventName, handler);
+            });
+        };
+        exports.proxyEventsPlugin = proxyEventsPlugin;
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/router.js" (__unused_rspack_module, exports, __webpack_require__) {
+        exports.getTarget = getTarget;
+        const is_plain_object_1 = __webpack_require__("./node_modules/.pnpm/is-plain-object@5.0.0/node_modules/is-plain-object/dist/is-plain-object.js");
+        const debug_1 = __webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/debug.js");
+        const debug = debug_1.Debug.extend('router');
+        async function getTarget(req, config) {
+            let newTarget;
+            const router = config.router;
+            if ((0, is_plain_object_1.isPlainObject)(router)) newTarget = getTargetFromProxyTable(req, router);
+            else if ('function' == typeof router) newTarget = await router(req);
+            return newTarget;
+        }
+        function getTargetFromProxyTable(req, table) {
+            let result;
+            const host = req.headers.host;
+            const path = req.url;
+            const hostAndPath = host + path;
+            for (const [key, value] of Object.entries(table))if (containsPath(key)) {
+                if (hostAndPath.indexOf(key) > -1) {
+                    result = value;
+                    debug('match: "%s" -> "%s"', key, result);
+                    break;
+                }
+            } else if (key === host) {
+                result = value;
+                debug('match: "%s" -> "%s"', host, result);
+                break;
+            }
+            return result;
+        }
+        function containsPath(v) {
+            return v.indexOf('/') > -1;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/status-code.js" (__unused_rspack_module, exports) {
+        exports.getStatusCode = getStatusCode;
+        function getStatusCode(errorCode) {
+            let statusCode;
+            if (/HPE_INVALID/.test(errorCode)) statusCode = 502;
+            else switch(errorCode){
+                case 'ECONNRESET':
+                case 'ENOTFOUND':
+                case 'ECONNREFUSED':
+                case 'ETIMEDOUT':
+                    statusCode = 504;
+                    break;
+                default:
+                    statusCode = 500;
+                    break;
+            }
+            return statusCode;
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/utils/function.js" (__unused_rspack_module, exports) {
+        exports.getFunctionName = getFunctionName;
+        function getFunctionName(fn) {
+            return fn.name || '[anonymous Function]';
+        }
+    },
+    "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/utils/logger-plugin.js" (__unused_rspack_module, exports) {
+        exports.getPort = getPort;
+        function getPort(sockets) {
+            return Object.keys(sockets || {})?.[0]?.split(':')[1];
+        }
+    }
+});
+__webpack_require__("./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/index.js");
+var dist__esModule = true;
+export { dist__esModule as __esModule };